What are variables in c programming?

Answer 1

A variable in C Programming is a memory allocation where a value may be stored and mutated. Rather than referencing the memory allocation by its physical address, we give it an easy-to-remember name. Each variable also has a type associated with. This tells the compiler how many bytes are allocated to the variable and how those bytes are to be interpreted. That is; the same binary representation has a different meaning depending upon the type.

A pointer is also a variable. We use a pointer variable to store a memory address and thus refer to that address being pointed at. We can also dereference that address and thus indirectly access the value stored at that address. Pointers make it possible for the same algorithms to refer to different memory addresses, allowing those algorithms to operate upon the values themselves. Without pointer variables, algorithms would only be able to operate upon copies of those values.

An array is a sequence of variables of the same type arranged in contiguous memory. These variables do not have names (they are anonymous) however we can refer to them through a zero-based index. The array name provides a reference to the start of the array and the array type determines how many bytes each element occupies, thus multiplying the index by the type's length determines the offset memory address of each indexed element in the array. The only thing we cannot determine is how many elements are allocated to the array; it is up to the programmer to maintain a count of elements using a separate variable; incrementing or decrementing the count each time the array is re-allocated.

Arrays cannot be passed to or returned from functions. This is because an array implicitly converts to a pointer variable when passed to a function. In order for the function to treat this pointer as an array, we must also pass the array's length.

A constant is the same as a variable except constants are not mutable. The seemingly contradictory term "constant variable" is sometimes used, however this specifically refers to a constant that falls from scope and is subsequently re-instantiated with a new value, as will happen when a function's formal argument is declared constant or when constant memory is allocated on the heap. Formal arguments are always allocated on the call stack and will fall from scope when the function returns. Global and local constants, however, are allocated in static memory (in the program's data segment) and will remain in scope throughout the program's life cycle. All constants must be assigned a value at the point of instantiation (when they come into scope) and that value cannot be changed while the constant remains in scope.