Analysis of C ++ typeof Basic Application Methods

The C ++ programming language can be seen as an upgraded version of the C language. It not only has various features of the C language, but also makes some improvements in some specific aspects, which greatly improves the development efficiency of developers in programming. Here we will explain in detail how to apply C ++ typeof.

I. Basic usage.

1. C ++ typeof expression.

The following lists the usage:

A. Type of the expression value:

 
 

  
  
template< class A, class B> 
  
  
function operator*(A a, B b) -> typeof(a*b); // return type last  
  
  
// big change: function keyword  
  
  
// : and return are obvious alternatives for -> 
  
  
template< class A, class B> 
  
  
typeof(a*b) operator* (A a, B b) ; // “lookahead parsing” 
 
 

Typeof (a * B) does not really calculate the value of a * B, but returns the type of calculation result.

B. Type of the expression:

 
 

  
  
template< class A, class B> 
  
  
typeof(A*B) operator*(A a, B b); // use typenames  
  
  
// not general  
  
  
template< class A, class B> 
  
  
typeof((*(A*)0)*(*(B*)0)) operator*(A a, B b); // hack 
 
 

Currently, only the gcc compiler supports this keyword.

2. auto keyword.

In the old syntax, auto identifies the storage type, indicating that this variable is valid within the range of this code block. This is the default attribute and can be left empty, so it feels a little redundant.

In c ++ 0x, auto has a new usage, which is similar to C ++ typeof. Its usage is as follows:

 
 

  
  
template< class A, class B> typeof(a*b) operator*(A a, B b)  
  
  
{  
  
  
auto x = a*b; // avoid replication of expression/type  
  
  
// …  
  
  
return x;  
  
  
}  
  
  
auto glob = x*y; 
 
 

It seems that its function is to save code and can be replaced by C ++ typeof.

Ii. Use.

From the basic usage above, you can easily handle different types of computing problems that were hard to handle in the past.

It can also be used in other scenarios. For example, a problem I encountered some time ago, such as the following common class:

 
 

  
  
struct A  
  
  
{  
  
  
int test ();  
  
  
}; 
 
 

In another class, you want to create A delegate compatible with the: test type (custom delegate class ):

 
 

  
  
struct B  
  
  
{  
  
  
Delegate < int()> test;  
  
  
}; 
 
 

It seems very easy to complete. But if my class A has 10 methods, should I define 10 delegates in Class B? In addition, it must deal with possible changes in Class. So I used macros to help generate class B:

 
 

  
  
BEGIN_DEFINE(B) // struct B{  
  
  
METHOD(A,test) // Delegate< ...> test;  
  
  
...  
  
  
END_DEFINE() // }; 
 
 

A method macro is the definition of a delegate based on the classes and methods specified in the parameter. How to obtain the: test type?

A: test itself is an uncertain type in C ++, unless it is static, and & A: test is A pointer value. Or that question, how can we get its type?

Trying to use the traits class template to separate types? Note that template parameters must be provided for a template class. Only template functions can export the type of template parameters themselves, and functions cannot be declared in the class.

Well, I don't need to talk much about it. Actually, using C ++ typeof is a simple implementation method:

 
 

  
  
Template <class T>
  
  
Class TypeTraits
  
  
{
  
  
TypeTraits (); // not implemented
  
  
};
  
  
// One of Multiple Special versions
  
  
Template <class T, class Ret>
  
  
Struct TypeTraits <Ret (T: *) ()>
  
  
{
  
  
Typedef Delegate <Ret ()> type;
  
  
};
 
 

The above METHOD can be defined:

 
 

  
  
#define METHOD(T,x) TypeTraits< typeof(&T::x)>::type x; 
 
 

This is the only method I have found. Record it first. The preceding section describes the specific application methods of C ++ typeof.