What is the syntax to declare the variable in c?

Answer 1

A variable is declared by declaring its name and type. Once a variable is declared you can use it in expressions, whether to assign a value or use the value. The name is also a reference to the memory address allocated to the variable, thus you can take the address of the name if required.

Answer 2

There are two types of variable in C Programming: named variables and anonymous variables. A named variable is a memory address that we can refer to by a user-defined name. This is useful because we cannot guarantee that a given variable will be allocated the exact same memory address on every execution, particularly if that variable is allocated on the stack (local variables). By referring to the variable by name in our code, the compiler can calculate the actual offset address at compile time (for static variables) or inject code to compute the offset address at runtime (for local variables). The name also makes it much easier for the programmer as they don't have to remember which variable is allocated to which offset address; the compiler can do that for us.

However, in order for the compiler to calculate the offsets for each named variable, it has to know how much memory is allocated to each of them. It also has to know what the value stored at that memory address signifies because the same representation can have infinite meanings. For instance, the value 65 is a decimal value, but it's also the ASCII character code for the letter 'A'. Both have the same binary representation (0100001), but that binary representation is only meaningful if we know what it actually represents. Perhaps the first four bits should be treated separately from the last four, in which case it may represent two completely separate decimal values: 4 and 1.

In order for the compiler to know which operations are valid for a given name it must know the name's type. The type not only determines how the memory should be interpreted it also determines its length. This is achieved by declaring the name to the compiler. For example:

int x;

Here we've declared the name x to be of type int. Note that no memory is actually allocated at this point; memory is only allocated when we actually use the name. However, the compiler now knows what x means and how much memory to allocate to it.

A variable's typename (such as int) is also a name. As with variable names, user-defined typenames must also be declared before they can be used. An int is a built-in type (already known to the compiler) so we don't require a declaration for it, but consider the following declaration:

T y; // error - T is undefined

Here we have declared y to be of type T but we haven't actually told the compiler what T represents. So we must declare it before we can use it:

struct T { char c;

double d;

};

T y; // error - T is undefined

This is one of the more annoying aspects of C because we "forgot" that T is not the typename, the actual typename is struct T.

struct T y; // ok

To avoid this annoyance, we typically use an alias:

typedef struct Tx {

char c;

double d;

} T;

Here we've declared T to be an alias for the type struct Tx. Although we've introduced yet another name (struct Tx), typenames don't consume any memory (only instances of the type use memory) and we can now use the alias more intuitively:

T y; // ok -- y is of type struct Tx

Declarations should always be placed at the top of the block of code in which they are used. this is determined by the names scope. For instance:

int a; // global scope

void f () {

int b; // local scope

// ...

}

Note that f is also a name; the name of a function. Like variable names, function names must also be declared before they are used (invoked). However, a definition is also a declaration so as long as the function definition is above any invocations of that function, we don't need a separate declaration (known as a forward declaration).

In cases where two functions have a circular dependency upon each other, at least one of them must be forward-declared. Consider the following:

void x (bool b) {

if (!b) y (b); // error: the name y is undefined

}

void y (bool b) {

if (b) x (b); // ok

}

To fix the above error we must forward declare the y name:

void y (bool); // forward declaration (required)

void x (bool b) {

if (!b) y (b); // ok

}

void y (bool b) {

if (b) x (b); // ok

}

We could also forward-declare the x function but it is not necessary in this case. However, it is good etiquette to declare all functions before defining them. For functions that are used by more than one translation unit, their declarations should be placed in header files that can then be included wherever required. this ensures the declarations are consistent across all translation units.

At the start of this answer I mentioned anonymous variables. Anonymous variables are variables that are allocated at runtime (as opposed to compile time). These variables are always allocated on the heap. As such, their offsets cannot be known in advance and cannot be calculated by the compiler; they could literally be allocated anywhere outside the process' address space. Since thy have no name, the only way we can refer to them is by their runtime addresses. To keep track of these addresses we use pointer variables:

in* p = malloc (1000 * sizeof (int));

Here we've allocated an array of one thousand integers. Imagine naming each and every one of them individually! The only variable name we actually use here is p, however that is the name of the pointer that stores the address of the allocation, not the name of the allocation itself. However, given that the point refers to the start address of the allocation, and that allocation contains integers (as denoted by the pointer's type, int), we can use array suffix notation on the pointer just as if it really were the name of the array:

p[100] = 42; // assign the value 42 to the anonymous variable at offset 100

Answer 3

you have to give a statement in the following syntax

datatype variable;

Answer 4

we can declare a variable using the following syntax

datatype variablename;

actually variable is the name given to the memory location which store values.

Answer 5

Simplest case:

the;

A more difficult case:

the [];