void and void* detailed

Rules for using the Void keyword:

1. If the function does not return a value, it should be declared as void type;

2. If the function has no arguments, declare that its argument is void;

3. If the function parameter can be any type of pointer, then declare its argument to be void *;

4. Void cannot represent a real variable;

Void represents an abstraction in which variables in the world are "typed"

#########################################################################
1. Overview
Many beginners do not understand the void and void pointer types in the C + + language, so there are some errors in their use. This article explains the deep meaning of the void keyword and

Detailed methods and techniques for using void and void pointer types.

Meaning of the 2.void
void literal means "no type", void * is "untyped pointer", void * can point to any type of data.

Void is almost only "annotated" and restricts the function of the program, since no one will ever define a void variable, let's try to define:


void A;

This line of statement compiles with an error, prompting "illegal use of type ' void '". However, even if the compilation of void A does not go wrong, it does not have any practical significance.

Void really plays a role in:
(1) The qualification of function return;
(2) The qualification of function parameters.

We will specify the above two points in the third section.

It is well known that if pointers P1 and p2 are of the same type, then we can assign values directly between P1 and P2, and if P1 and P2 point to different data types, you must use mandatory type

The conversion operator converts the pointer type to the right of the assignment operator to the type of the left pointer.

For example:
float *P1;
int *p2;
P1 = p2;

where P1 = P2 statement will compile error, prompt "' = ': cannot convert from ' int * ' to ' float * '", must be changed to:
P1 = (float *) P2;
While void * is different, pointers of any type can be assigned directly to it without forcing type conversions:
void *p1;
int *p2;
P1 = p2;

This does not mean, however, that void * can also be assigned to other types of pointers without forcing the type to convert. Because "no type" can contain "have type", "have type" cannot package

The "no type" tolerance. The truth is simple, we can say "men and women are people", but can not say "man is a Man" or "man is a woman." The following statement compiles an error:
void *p1;
int *p2;
P2 = p1;

Hint "' = ': cannot convert from ' void * ' to ' int * '".

Use of 3.void

The following rules are given for the use of the Void keyword:
Rule one if the function does not return a value, it should be declared as void type

In the C language, a function that is not qualified with a return value type is processed by the compiler as a return integer. But many programmers mistakenly think of it as void type. For example:
Add (int a, int b)
{
return a + B;
}
int main (int argc, char* argv[])
{
printf ("2 + 3 =%d", add (2, 3));
}

The result of the program running is output:
2 + 3 = 5
This means that a function that does not add a return value description is indeed an int function.

"The C + + language has very strict type security checks and does not allow this to happen (the function does not add a type declaration)," said Dr. Lin Rui, "high quality C + + programming". But compile

The compiler does not necessarily think so, for example, in visual c++6.0 the above Add function compiles without errors or warnings and runs correctly, so you cannot expect the compiler to do strict type checking.

Therefore, in order to avoid confusion, we must specify a type for any function without a leak when we write A/C + + program. If the function does not return a value, be sure to declare it as void class

Type. This is both the need for good readability of the program and the requirements of programming norms. In addition, the "self-commenting" function of the code can also be played after the void type declaration is added. The code's "self-injection

The code can annotate itself.

Rule two if the function has no arguments, declare that its argument is void

Declare one of these functions in the C + + language:
int function (void)
{
return 1;
}

It is not legal to make the following call:
function (2);

Because in C + +, the function parameter is void meaning that the function does not accept any arguments.

We compile in Turbo C 2.0:
#include "stdio.h"
Fun ()
{
return 1;
}
Main ()
{
printf ("%d", Fun (2));
GetChar ();
}

Compiles correctly and outputs 1, which means that in C, you can pass arguments of any type to a function without parameters, but compiling the same code in the C + + compiler will make an error. In C + +

, you cannot pass any parameters to a function without parameters, and the error prompts "' Fun ': function does not take 1 parameters".

Therefore, in C or C + +, if the function does not accept any arguments, be sure to indicate that the argument is void.

Rule three beware of using void pointer types

By the ANSI (American National standards Institute) standard, you cannot perform algorithmic operations on void pointers, that is, the following operations are not valid:
void * PVOID;
pvoid++; ANSI: Error
PVOID + = 1; ANSI: Error
The ANSI standard is determined because it insists that the pointer to the algorithm operation must be determined to be aware of its point to the data type size.
For example:
int *pint;
pint++; ANSI: Correct

The result of pint++ is to make it grow sizeof (int). (Test on VC6.0 is a multiple of sizeof (int))

However, the famous GNU (GNU's not UNIX abbreviation) does not assume that it specifies that the algorithm operation of Void * is consistent with char *.

The following statements are therefore correct in the GNU compiler:
pvoid++; GNU: Correct
PVOID + = 1; GNU: Correct

The result of Pvoid++ 's execution was that it increased by 1. (Test on VC6.0 is a multiple of sizeof (int))

In the actual program design, in order to meet the ANSI standard and improve the portability of the program, we can write code that implements the same function:
void * PVOID;
(char *) pvoid++; ANSI: correct; GNU: Correct
(char *) pvoid + = 1; ANSI: Error; GNU: correct

There are some differences between GNU and ANSI, and in general, the GNU is more "open" than ANSI, providing support for more grammars. But when it comes to real design, we should try to cater to

ANSI Standard.

Rule four if the parameter of a function can be any type of pointer, then declare its argument to be void *

Typical function prototypes, such as memory manipulation functions memcpy and memset, are:
void * memcpy (void *dest, const void *SRC, size_t len);
void * memset (void * buffer, int c, size_t num);

In this way, any type of pointer can be passed into memcpy and memset, which also truly embodies the meaning of the memory manipulation function, because the object it operates is only a piece of memory, not

What type of memory this piece of RAM is. If the parameter type of memcpy and memset is not void *, but char *, then shouting truth is strange! Such memcpy and memset are obviously not a

"Pure, out of the vulgar" Function!

The following code executes correctly:
Example: Memset accepts arbitrary type pointers
int intarray[100];
memset (intarray, 0, 100*sizeof (int.)); The intarray will be cleared 0

Example: memcpy accepts arbitrary type pointers
int intarray1[100], intarray2[100];
memcpy (Intarray1, Intarray2, 100*sizeof (int.)); Copy the Intarray2 to Intarray1

Interestingly, the memcpy and memset functions return a void * type, and the writer of standard library functions is so knowledgeable!

Rule five void cannot represent a real variable

The code below attempts to have void represent a real variable, so it's all the wrong code:
void A; Error
function (void a); Error

Void embodies an abstraction in which variables in the world are "typed", such as a person who is not a man or a woman (and a shemale?). ）。

Void appears only for an abstract need, and it is easy to understand the void data type if you correctly understand the concept of an object-oriented "abstract base class". As cannot be pumped

As the base class defines an instance, we cannot define a void (the "abstract data type") variable that lets us make an analogy.

4. Summary
The small void contains a very rich design philosophy, as a program designer, a deep level of thinking about the problem will certainly benefit us. No matter what type of pointer (void*, char*, int*, float* ...) The default initial value is 0xcccccccc//this should be different for each compiler, this is for VC6

#include <iostream.h>
#include <memory.h>
#include <string.h>
void Main ()
{
void *p1;
int a = 10;
int *P2 = &a;
cout << p1 << Endl;
cout << (int) *p2 << Endl;
P1 = p2;
cout << * (int*) P1 << endl;//!!!!!!! Operation output value with empty type!
cout << (int) *p2 << Endl;
}
/* Output:
0xCCCCCCCC
10
10
10
*/

The declaration is assigned null at the same time, and is set to null immediately after the delete.


In the debug version, the default initial value of the pointer is 0xCCCCCCCC, the release version under the initial value of 0x0000000a, (on My Computer VC6.0). For a pointer, if there is no appropriate initialization value for the moment, it should be set to null (0).
For good programming habits, declare a pointer, initializes null, and if the class member is initialize in the constructor, it is null when the pointer is used with delete.


0xCCCCCCCC is just the undefined pointer value generated by the VC in the debug state to indicate that the pointer is uninitialized and will not equal this value in the release state (unless coincidental). For a pointer, if there is no appropriate initialization value for the moment, it should be set to null (0).

void and void* Detailed (EXT)