What is auto declaration in C?

Answer 1

Auto is one of the four storage classes in c. This is the default storage class. The auto storage class can be used only inside functions, i.e. only to declare local variables and not to declare global variables. All the local variables are by default auto variables.

Other storage classes are:

Register - variables declared may get stored in CPU registers instead of RAM

Static - default storage class for global variables

extern - defines global variables that is visible to all object modules

Answer 2

You can use it within functions only, it means a variable which exists on the stack. (This is the default, so you don't have to actually use it, most programmers do not even know about this keyword, let alone use it.)

Answer 3

Objects and variables defined within a block (statements enclosed in braces {}), or in a function signature have auto storage unless otherwise specified using the extern or static keyword. Automatic objects have no linkage, are stored on the program stack, and persist until the end of the block in which they are declared. Although objects and variables can be specified using the auto keyword, explicit use of auto is unnecessary. Its only purpose in C++ is for clarity.

Answer 4

It does exactly the same as it did in C++11; automatic type deduction through initialisation.

Any function that returns a type other than void can be used to initialise a variable of the same type. However, in order to declare that variable we must first know the function's type and if we don't know its type, then we have to look it up. But with automatic type deduction through initialisation we can simply enlist the compiler to perform the lookup for us:

auto x = foo();

If we suppose that foo() returns a double, then this would be equivalent to:

double x = foo();

Generally we only use automatic type deduction through initialisation when the return type is an implementation detail that would otherwise hinder the readability of our code. For instance, the C++ standard library contains many examples of verbose data types. Even if we import names in order to reduce the verbosity, our code can still be a little difficult to digest:

#include<iostream>

#include<chrono>

int main (void) {

using namespace std::chrono;

steady_clock::time_point start = steady_clock::now();

// perform the task...

steady_clock::time_point end = steady_clock::now();

long long duration = duration_cast<milliseconds>(end - start).count();

std::cout << "Duration: " << duration << "ms.\n";

}

In this code, the std::chrono::steady_clock::time_point data type is an implementation detail that is of no real concern to the reader. As such we can reduce the verbosity even further by using automatic type deduction through initialisation:

#include<iostream>

#include<chrono>

int main (void) {

using namespace std::chrono;

auto start = steady_clock::now();

// perform the task...

auto end = steady_clock::now();

auto duration = duration_cast<milliseconds>(end - start).count();

std::cout << "Duration: " << duration << "ms\n";

}

The duration calculation is another implementation detail that could be simplified with a little helper function, however the use of automatic type deduction alone greatly improves the readability of this otherwise trivial piece of code.