Auto和Void之间的区别？

Question

I am reading the C++ Primer Book (fifth edition) and I have a question upon the book i am reading. It says:

The type void* is a special pointer type that can hold the address of any object. Like any other pointer, a void* pointer holds an address, but the type of the object at that address is unknown.

Ok, so I understand that but… I have many contradictions to the statement. First of all, can't you use auto ? Doesn't it do the same thing as void ? Meaning aren't

void *somePtr;

and

auto *somePtr;

the same?

Second of all it says the type of the attached address is unknown. Can't you use typeid to get the type? Like this:

int a = 5;
auto *somePtr = 5;
std::cout << typeid(*somePtr).name() << std::endl;

Answer 1

Did you try running your examples through a compiler? As it happens, neither

auto * p;  // error

nor

int a = 0;
void * p = &a;
std::cout << typeid(*p) << '\n';  // error

will compile while both

void * p;

and

int a = 0;
auto * p = &a;
std::cout << typeid(*p) << '\n';

are fine.

To give an informal and easy to remember analogy for void * and auto * , think of void * p as telling the compiler

Don't care about what p pointer points to, I'll handle it myself (at run-time).

whereas auto * p = (expression) tells the compiler

Please figure out for me (at compile-time) what (pointer) type (expression) evaluates to and make the type of p be accordingly.

As a matter of fact, auto * is rarely useful. You can simply write auto instead and if the initializing expression is a pointer type, the auto will be deduced to be a pointer, too.

Answer 2

auto uses compile-time type inference : the variable has a definite type which is its correct type, however the type is inferred from its value. Throughout the lifetime of the auto variable, the compiler will ensure that it is being used in accordance with its actual inferred type

void* can indeed hold the address of any object, but as opposed to auto , you must explicitly convert the void* pointer to a different type before using it. Unlike auto that conversion is explicit, and unlike auto the compiler cannot warn about improper usage.

Answer 3

From the compiler's viewpoint :

• In C++11 auto uses the same rules of inference as template argument deduction . It basically tells the compiler: "Deduce the type from the initializer."
• void * tells the compiler: "Here is a pointer pointing to an object whose type cannot possibly be known at compile time."

For auto the actual type is deduced at compile time , so the compiler can warn about possible misuse.

For void * the actual type is deduced in code by the programmer using a reinterpret_cast to cast to a known pointer type, typically at the point of execution of that segment of code.

---

From the programmer's viewpoint :

• Hey compiler I'm too lazy or too clumsy to write the type. I'll just auto it and let you figure out the rest. (And it looks smaller than the type I was about to write. Except for int .)
• Hey compiler, don't you dare mess with my void * . I'll figure out the type at runtime myself (in code...) when I need it.
  • Useful for runtime polymorphism as the same pointer can be used to point to objects of different types as needed in the context.
  • Also useful if you are coding a base class and you client needs to store an object of an User Defined Type defined by the client.

---

So NO auto is NOT equivalent to void . void means nothing . In fact you can't even declare a variable of type void . void * however is a special type of pointer that can point to anything! And auto * is redundant, just use plain old auto instead.

In your example,

 int a = 5; auto *somePtr = 5; std::cout << typeid(*somePtr).name(); << std::endl; 

You assigned an address 5 to somePtr which is illegal. Needlessly stating that *somePtr is also illegal in that context. Although auto is probably deduced to an int , which is what you wanted to print.

Well with modern C++ techniques, you rarely see void * s and reinterpret_cast s or any raw pointers for instance except deep within any library implementation internals.

Answer 4

To answer your first question,

void and auto are not same. When you declare a variable of auto, it means it takes the data types of the value assigned .

for ex:

auto a = 5 // 'a' is of type integer

auto a = 5.0 // 'a' is of type float etc.,

The actual difference can be observed while dereferencing.

The above statement "the actual difference can be observed while dereferencing" answers your second question.

void* cannot be deferenced, whereas auto* can be deferenced

Answer 5

In case auto variable it will take data type of variable from whom it is getting assgnied. For example Auto obj = class_obj. Here data type of class_obj became data type of obj. You no need explicetly remember and type cast. In case void * you need to know data type and do type cast explicetly.