Experience Sharing from C to C ++ (2)

C ++Although the technology is very fashionable, many C users want to label themselves as C ++ in the shortest time. There are a lot of books about C ++, but only those users who are lucky enough to get started will occasionally flip over. There are still a lot of hooligans wandering at the door of C ++.

This article only targets C users, preferably a very good old user. For example, he tries to use pointers when encountering the simplest problem ), through some C and better C ++, this article uses Borland C ++ 3.1) routines to introduce some knowledge about C ++, so that readers and friends can "dive deeper and deeper ", easy to use C to C ++!

Ii. Challenges # define

# Define is a very useful Command provided by C, but in C ++, it is very likely that macro commands are not used.

1. the const macro command allows you to specify the value of an identifier as a constant,

For example: # define PI 1415926

It can also be used to define a string: # define HZK16 "HZK16F" the following can be used through:

 
 

  
  
cout << "PI is“<<PI;  
  
  
cout << "Filename: "<< HZK16;  
 
 

Macro is not a legal object after all, although it is disguised as perfect. C ++ provides the constant modifier const for you to specify the value of an object as a constant. It prevents users from assigning values or other side effects,

Similar to the preceding example:

 
 

  
  
const float PI=3.1415926;  
  
  
char*const HZK16="HZK16F";  
  
  
PI = 3. 14; //error  
  
  
HZK16="HZK16K"; //error: Cannot modify a const object  
 
 

However, pointer processing seems complicated. For example, the following operations are legal:

 
 

  
  
HZK16[5]=’r’; //ok HZK16 ="HZK16K" 
 
 

It is necessary to clearly understand the scope of const modification. The declaration form and corresponding meaning are as follows:

 
 

  
  
Char * const cpl = "I love you! '; // Const modifier' * ', cp1 is a pointer constant pointing to a character
  
  
Const char * cp2 = "I hate you! '; // Const modifier 'Char' cp2 is a pointer to a character constant
  
  
Const char * const cp3 = "Get the hell out of here! "; // Const modifier 'Char 'and '*',
 
 

Cp3 is a pointer constant pointing to a character constant. Therefore, the following usage is still valid:

 
 

  
  
strcpy(cpl "Oh no...“);  
  
  
cp2++; 
 
 

Cpl only keeps an eye on a specific address, and it is not its responsibility to prevent the content from being rewritten. cp2 is the opposite. It does not allow you to modify the content, but it can be pointed by you (this may be worse ). Only using two modifiers (such as cp3) can be the safest way.

Pointer to const cannot be assigned to pointer to non-const:

 
 

  
  
float*p=Π  
  
  
//error: Cannot convert 'const float*’ to 'float*’  
  
  
*p=3.14; 
 
 

This restriction ensures the valid meaning of constants. Note that indirect modification of constants caused by Explicit conversions is possible:

 
 

  
  
// Test08.cpp
  
  
# Include <iostream. h>
  
  
Void main ()
  
  
{
  
  
Char * Spy;
  
  
Const char * const String = "Yahoo! ";
  
  
Spy = (char *) String;
  
  
Spy [5] = '? ';
  
  
Cout <String;
  
  
}
  
  
Output result: Yahoo!
 
 

2. inline function in line function)

Macros can obtain functions similar to functions in some scenarios. The following is a common example: # define ADD a B) a) + B ))

Cout <"1 + 2 =" <It outputs the data summation function, but we have at least one reason to refuse to use it. The following are the most obvious reasons:

① Macros lack type security detection, such:

 
 

  
  
ADD 'A' 0. 0l）； 
 
 

Such a call will be interpreted as legal, but in fact few users expect such a statement to be written;

② Macros do not introduce temporary copies for parameters, such:

 
 

  
  
#define DOUBLE (x)((x)+(x))  
  
  
int i(1);  
  
  
cout<<DOUBLE(i++); //prints '3'  
 
 

③ Macros do not have addresses. For example, they may exist in a calculator program:

 
 

  
  
case ' +'： Operator = & ADD； 
 
 

It cannot be reasonably explained.

Take the function? However, using a function is not the most cost-effective, and it wastes valuable execution time. Readers who have used assembly languages may know that in general, some field protection work should be done before and after the real function execution, when the function volume is very small, this redundant workload will be much greater than the function itself.

Therefore, C ++ provides the keyword "inline". When you want the compiler to directly Insert the code of a function into the call point, you can set it as an inline function, add the keyword inline when defining a function, for example:

 
 

  
  
//test09.cpp  
  
  
#include <iostream.h>  
  
  
inline int Add (int a int b)  
  
  
{  
  
  
return a + b;  
  
  
}  
  
  
void main O)  
  
  
{  
  
  
cout<<"1+2=“<<Add(1 2);  
  
  
}  
 
 

The main function will be interpreted by the compiler:

 
 

  
  
count<<"1+2=“<<{1+2 }； 
 
 

The behavior is similar to the ADD a B) Macro of the worker. Experience shows that it is wise to declare frequently used and very small functions as inline.

3. Function overload)

In actual data summation operations, the Add function provided in the above section is far from enough. You have to Add other code, such:

 
 

  
  
double AddDouble(double a double b)  
  
  
{  
  
  
return a + b;  
  
  
}  
  
  
float AddFloat (float a float b )  
  
  
{  
  
  
return a + b;  
  
  
}  
 
 

In particular, you can play with the name Technique in C ++ and name all the above AddDouble AddFloat names as Add, for example:

 
 

  
  
double Add(double a double b)  
  
  
{  
  
  
return a + b;  
  
  
} 
 
 

Rest assured that the compiler will safely find the corresponding function prototype for different calling forms. For example:

 
 

  
  
double a b;  
  
  
Add(f 2); //int Add(int int)  
  
  
Add (a b); //double Add (doubledouble)  
 
 

In this way, different functions have the same function name, that is, function overloading. Function overloading and subsequent templates and virtual functions form the "one interface, multiple functions" feature, namely, polymorphism), which is one of the technologies of object-oriented OO.

When using the overload mechanism, C ++ puts forward many restrictions to prevent ambiguity, such:

 
 

  
  
void fun(int a);  
  
  
int fun(int a);  
  
  
void fun(int& a);  
  
  
void fun (int a int b=0);  
 
 

It is likely to cause a panic in the C ++ compiler, and it will be very dissatisfied when it encounters calls such as fun100. The user is obligated to ensure that any call form does not produce ambiguity. The following is a common example of using the overload mechanism:

 
 

  
  
//test10.cpp  
  
  
#include <graphics.h>  
  
  
#include <iostream.h>  
  
  
void Pixel(int x int y int color)  
  
  
{  
  
  
putpixel(x y color);  
  
  
}  
  
  
int Pixel(int x int y)  
  
  
{  
  
  
return getpixel(x y);  
  
  
}  
  
  
void main()  
  
  
{  
  
  
int Driver=VGA Mode=VGAHI;  
  
  
initgraph(&Driver &Mode "");  
  
  
Pixel(100 100 4);  
  
  
int Color = Pixel(100 100);  
  
  
closegraph();  
  
  
cout << "Color of point(100 100):" << Color;  
  
  
}  
 
 

As you can imagine, C ++ encodes the different Pixel functions above into Pixel_iii and Pixel_ii respectively. The format includes the data types of each entry parameter. Note that encoding does not contain the returned value information. Therefore, function overloading dependent on the differences in returned value types is unstable. Therefore, the connector linker can find the corresponding module without any effort. However, it may be difficult to add module connections between the new and old versions of C, because the traditional C function library does not have the bad habit of using function names, C ++ has to provide the keyword extern to ensure the security of this connection. Note that 'C' can be capitalized as follows ):

 
 

  
  
extern "C" 
  
  
{  
  
  
void Pixel(int x int y int Color);  
  
  
};  
 
 

It tells the compiler to find the corresponding Pixel module in the function library instead of being smart. While

 
 

  
  
Extern "C"
  
  
{// '# Include' must start another line
  
  
# Include "function. h"
  
  
};
 
 

The Declaration is contained in the header file function. h. All function modules adopt C connections.

I hope this article will help you. Please refer to the next article>