C programming language

Details

Last Updated: Thursday, 15 October 2020 18:38

Published: Friday, 12 October 2018 04:46

Hits: 894

C programming lang: Most popular language of last 50 years. Must learn language which can be used to write any simple or complex pgm

C library ref guide: http://www.acm.uiuc.edu/webmonkeys/book/c_guide/index.html

C language has it's own syntax, which may not seem very easy for a person who is used to more modern languages like python. We'll start with very basic "Hello World" pgm which prints "Hello World" on screen. This pgm is explained under "gcc" section, but I'm repeating it here. Name the pgm hello.c

 
main function: Every C pgm needs a main function. This is where the pgm starts executing from line by line.

arguments to main() function are optional. argc and argv variables store the parameters passed in cmd line of the shell when running the pgm.On POSIX compliant systems, char *envp[] contains vector of program's environment var (i.e SHELL environment var that are passed to the program

argc=num of arguments in cmd line including cmd name,

argv[]= vector storing arguments in cmd line, argv[0]=cmd_name (1st argument), argv[1]=2nd argument (1st option), and so on

envp[] = vector storing ENIRONMENT variables

argc, argv[] and envp[] can be any names, i.e main(int cnt, char * arr_option[], char *arr_env[]); is equally valid, though usimg argc, argv and envp is standard

ex: a.out 1 myname 17cd => argc=4 (4 arguments on cmd line), argv[] = {"a.out"  "12", "myname", "17cd" }; Note that argv is an array of strings(char), so even numbers are stored as string. Char strings "12" can be converted to numbers using atol() for 64 bit int conversion or atoi() for 32 bit. i.e y=atoi(argv[1]); => This will assign y to integer 12. Plain casting using (int) will not work, as (int)"12" will convert string 12 to integer which will be ascii code of 1,2,\n converted to integer.
 
int main (int argc, char *argv[]) { // int before main refers to the return value of main. In early days of C, there was no int before main as this was implied. Today, this is considered to be an error (even if main doesn't return any value).

int main (void) { => no arguments to main
...
exit (1); //return value from int. Can also do: return 1;
}

Compile C pgm: We can't run C pgm directly by typing hello.c on terminal. We need to compile it first, which generates an executable "a.out", and then run "a.out" on terminal.To compile above pgm, we use gcc compiler. Type below cmd on terminal. Look in "gcc" section for details.

gcc hello.c => generates a new file a.out. Now type ./a.out on terminal, and it runs the pgm

Syntax of C pgm:

1. comments start with // for single line comment, For multi line comment, use /* comment */

2. Each stmt ends with semicolon ;. We don't need semicolons for blocks

3. main() function is needed. We can define other functions as needed.

4. All variables need to defined before using them. We define the var and specify their type. Types are explained below.

5. For loops, if-else,etc are supported. Many reserved keywords are defined for these, and they can't be used as variable names,

Std Input/Output functions:

printf and scanf are 2 std functions that are going to be used the most. They are inbuilt library functions in C programming language which are available in C library by default. These functions are declared and related macros are defined in “stdio.h” which is a header file in C language. That's why we have to include “stdio.h” file.

1. printf: printf() function is used to print the (“character, string, float, integer, octal and hexadecimal values”) onto the output screen.

ex:

int var1=5; // var1 used in printf below. We define it to be of integer type and assign it a value of 5.

printf ("Value is = %d \n",var1); // %d specifies that var1 is int type, and should be printed in decimal format. var1 needs to be defined before it can be used. var1 is put outside " .. ", while %d is inside " ...". \n is used to print a newline.

2. scanf: scanf() function is used to read character, string, numeric data from keyboard.

ex:

char ch; //var ch is defined of type "character", and is used to stre the i/p entered by the user.

printf("Enter any character \n"); //This printf is same as before. We can't print anything from within scanf. It can only take input. So, we usually precede scanf with printf.

scanf("%c", &ch); //Same as in printf, we have to specify the type of i/p. Here %c says it's character type, and whatever character user enters on prompt is stored in var "ch". Here var "ch" has to be defined as a "char type" before using it. We use an & with ch. That is needed, and will be xplained in pointer section below. No & is needed for var in printf function.

Type:  In C pgm, we have to define data type of all the variables, else C compiler will error out. These are 2 categories of data types for any var. Primary data types and derived data types
-----

I. Primary data type: These are fundamental data types in C namely integer(int), floating point(float), character(char) and void.
arithmetic type: 4 basic types: char, int, float, double and 4 optional type specifiers (signed, unsigned, short, long). void is a data type for nothing.

1. char: 8 bits.
 char, signed char, unsigned char => signed char stored as signed byte. If we use "char" to store character then ascii code for that character is stored. In that case signed or unsigned doesn't matter. However, if we use char to store 8 bit number, then signed unsigned matters, as it represents 8 bit signed or unsigned integer. As "int" stores integers in 16 bit or larger, the only way to store 8 bit integers is by using signed/unsigned char. signed char is from -128 to +127, while unsigned char is from 0 to +255.
 Normal char (no signed/unsigned) are represented in ASCII codes. See in ASCII part of "bash shell scripting language" section.

2. int: 16 bits to 64 bits.
 A. short integer type. atleast 16 bits in size => short, short int, signed short, signed short int, unsigned short, unsigned short int.
 B. basic integer type. atleast 16 bits in size => int, signed, signed int, unsigned, unsigned int. usually 32 bits.
 C. long integer type. atleast 32 bits in size => long, long int, signed long, signed long int, unsigned long, unsigned long int. usually 64 bits, but on embedded arm uP, these are 32 bits.
 D. long long integer type. atleast 64 bits in size => long long, long long int, signed long long, signed long long int, unsigned long long, unsigned long long int. Usually 128 bits, but on embedded arm uP, these are 64 bits.

3. float: IEEE 754 single precision floating point format (32 bit: 1 sign bit, 8 exponent bit and 24 significand precision(23 explicitly stored since 1 bit is hidden)).

4. double: IEEE 754 double precision floating point format (64 bit: 1 sign bit, 11 exponent bit and 53 significand precision(52 explicitly stored since 1 bit is hidden)). "double double" is extended precision floating-point type. It can be 80 bit floating point format or some non-IEEE format.
 
NOTE:  The above types don't have particular size as part of C lang, as it's target processor dependent. So, their size is provided via macro constants in two headers: limits.h header defines macros for integer types and float.h header defines macros for floating-point types.
limit.h: (look in http://www.acm.uiuc.edu/webmonkeys/book/c_guide/2.5.html)
-------
In cortex M0, char size is defined in /apps/arm/rvds/4.0-821/RVCT/Data/4.0/400/include/unix/limits.h as follows:
#define CHAR_BIT 8 => Number of bits in a byte. The actual values depend on the implementation, but user should not define these to be lower than what's put here.
#define CHAR_MIN 0 => minimum value for an object of type char
#define CHAR_MAX 255 => maximum value for an object of type char

similarly signed char is defined as -128 to +127 (8 bits), unsigned char is 0 to 255, signed short int or int is -32768 to +32767 (16 bits), signed long int is -2147483648 to +2147483647(32 bits).

float.h: (look in http://www.acm.uiuc.edu/webmonkeys/book/c_guide/2.4.html)
--------
for float(32 bits), double(64 bits), long double(80 bits).
ex: In cortex M0 float.h, we have:
#define FLT_MAX  3.40282347e+38F

Compiler uses these files to determine size of these primary data types. So, the same pgm may compile differently on different m/c if these files have diff values.

II. Derived data types: Derived data types are nothing but primary datatypes grouped together like array, stucture, union and pointer.

Boolean type: _Bool (true/false). It's an unsigned byte. False has value 0 while true has value 1. It can be seen as derived from int.

In cortex M0 stdbool.h, bool is defined as _Bool, true as 1 and false as 0. (for C compilers pre C99 std). C++ has bool type instead of _Bool type (as per C99 std).
#define bool _Bool
#define true 1
#define false 0

pointer type:

Pointer type var are a new class of var that store addr. Addr could have been stored as type int, but a special "pointer" type was declared to store the addr. For every type T (i.e char, int, etc) there exists a type pointer to T. Variables can be declared as being pointers to values of various types, by means of the * type declarator.
eg:
char v; declare var v as of type char. To get addr location of any variable, use &. So, addr of v is &v
char *pv; (can also be written as char* pv; or char * pv;)=> declares a variable "pv" which is a pointer to value of type char. pv doesn't store a char, but rather an addr. That addr stores a char var. *pv refers to contents stored at memory pointed to by this addr (the addr stored in var pv). &pv is the addr of this var pv, just like &v is the addr of var v. Since, var v istores char, it is just 1 byte in length, while var pv stores an addr, which is 32 bits on a 32 bit system. We can initialize pv to any addr, including special value "NULL" (pv=NULL;):
char *pv=0x1000; => assigns pv to addr value 1000. This is similar to char *pv;pv=0x1000; However, this will error out with this msg: "a value of type "int" cannot be used to initialize an entity of type char *". Reason is although C language allows any integer type to be converted to a pointer type, but such conversions cannot be done implicitly; a cast is required explicitly to do this non-portable coversion. so, we have to do: char *pv = (char *)0x1000; => This casts 0x1000 to pointer type pointing to a char var, which is exactly what pv is, so both sides become same type.

char v='a';
char *pv=&v; => assigns pv to addr loc of variable v. If we print various values of v and pv, this is what we might get:

printf ("v=%c, &v=%x, pv=%x, &pv=%x, *pv=%c",v,&v,pv,&pv,*pv); => v and *pv both store char, so we use %c, while pv, &v and &pv store addr, so we use %x

v=a, &v=f98ca5cf, pv=f98ca5cf, &pv=f98ca5c0, *pv just happens to store the char

pv = &v; => assigns addr loc of v to pv. If pv wasn't declared as a pointer, we could not do this.
pv = (char *)0x1000; => pv is assigned addr value of 1000. The addr 0x1000 stores a char type.
*pv = 0; => store 0 in contents stored at addr pointed by pv.

initializing ptr var: We can initialize ptr var to any addr val. However we can also initialize the contents of ptr var via this:

char *p="Name"; => Here p is created as a ptr and values assigned from addr p, p+1 and so on. So, *p='N', *(p+1)='a', and so on to *(p+4)='\n'. *(p+5) is not initialized to anything, and contains garbage value.

Below 2 assignments are used extensively for rd/wrt of reg mem locations:
1. Rd from given mem loc: 0x1000 or "#define addr 0x1000"
data = *((char *)0x1000); => grab contents of addr loc 0x1000 and assign it to data.
2. Wrt to given mem loc: wrt 1 or "0x01" (since char, so 1 byte only, so 0x01. If short int, use "0x0001")
*((char *) 0x1000) = 1; => This stores 0x01 at addr 0x1000 (Note: it is not char '1' as char '1' is ascii value 0x31. Here we cast 0x1000 to type "pointer of type char" and then "*" in front of it refers to contents stored at addr 0x1000. So, we store "1" at that addr. We can omit extra brackets and do: *(char *) 0x1000 = 1; NOTE: if we try to do: *0x1000=1; then we get this error "operand of "*" must be a pointer" as 0x1000 is a int and not a pointer, so explicit conversion is required.

double pointer: When the pointer stores addr of other pointer (instead of storing addr of char, int, etc), it's pointer to a pointer or double pointer

ex:

int **dpv; => here dpv is double ptr to type int. dpv stores addr of pointer pv for ex, where pv pointer points to data tof ype int

int *pv; => pv is the ptr pointing to data type int.

int v; => regular var decalred as int

pv = &v => single ptr pv is assigned addr of var "v".

dpv = &pv; => double ptr dpv is assigned addr of ptr pv. If dpv wasn't declared a double ptr, then &pv couldn't be assigned to dpv. If dpv was declared a single ptr (i.e int *dpv), then dpv could store addr of regular var "v" and not addr of single ptr pv.

use of double ptr: We use it arg of functions, when we want to change the contents of a var which is outside the function, from inside the function.

1. We use it in arg of main func:

ex: int main(int argc, char **argv) => here we could use char **argv or char *argv[]. It represents an array of char sequences.


2. We use it  in arg of regular func:

Array: An array is defined as finite ordered collection of homogenous data, stored in contiguous memory locations.

Array types are introduced along with pointers, as in C, arrays are just a pointer to the first object of that data in the memory. In most contexts, array names "decays" to pointers. In simple words, array names are converted to pointers. That's the reason why you can use pointer with the same name as array to manipulate elements of the array.

ex: char p[10] = "Name"; => This declares an array of 10 char type var = p[0] to p[9]. It is initialized to value "Name", so p[0]='N', p[1]='a',..p[4]='\n', and p[5] to p[9] are uninitialized. p[0] to p[9] are stored in continuous mem locations, and *p or p[0] refers to first element of array *(p+1) or p[1] to second element of array and so on. The way compiler translates array is that it stores it as stores "p" as ref addr, and then uses it to figure out p[0] = *p, p[1] = *(p+1) and so on. This is similar to char *p="Name";

ex: printf("ptr: p addr in hex= %x p addr in dec= %d &p= %x &p[0]=%x *p=%c &p[1]=%x *(p+1)=%c\n",p,p,&p,&p[0],*p,&p[1],*(p+1));

o/p => ptr: p addr in hex= 23fccc60 p addr in dec= 603769952 &p= 23fccc60 &p[0]=23fccc60 *p=N &p[1]=23fccc61 *(p+1)=a //as can be seen, p, &p and &p[0] all refer to addr of start of array p. We can use any of them to access array p. p is used as a ptr to start of array p[9:0].

There are some special cases when an array doesn't decay into a pointer. ex: char str[] = "Name"; Here the size of array is not explicitly specified, so not treated as pointer.

2D array: 2D array are simply double pointers. To see it, consider 1D array, where first element of array is referred via ptr *p. ptr p stores the addr of p[0].  Now consider 2D array. So, p[0][0] to p[0][n] is the first row of 2D array, p[1][0] to p[1][n] is the second row of 2D array and so on. So, to store each row of array, we can have a ptr *p for 1st row, ptr *q for next row and so on. Or we can have an array of ptr *p[] that will store 1st row, 2nd row and so on. So, ptr *p[0] points to 1st element of 1st row, ptr *p[1] points to 1st element of 2nd row and so on. So, it becomes 1D array of pointers, char *p[0], char *p[1] and so on. But any 1D array can be represented by pointers, so p[0], p[1] etc which are pointers can be rep by *p. But *p means p[0], p[1] are char and not ptr. To specify that p[0], p[1] etc are pointers to char, and not char themselves, we specify it as a double ptr, char **p or an array of single pointers as char *p[].

struct:

Struct type is collection of different kind of data which we want stored as single entity. For ex a person's account may contain name, age, income, etc.We can obviously make 3 different types of array: char type for name, int type for age, float type for income, etc. But that would be not easy to manage. However, we can group all these items together in a structure named "account", and then access each of these. That way, we have to create an array of just this "account" type, and it's much easier to manage data.

struct pointer:
------
struct reg { int a; char ch;};
struct reg arr[] = {{1,'s'},{2,'f'}}; //defines arr[0],arr[1] with values of reg type
struct reg *my0 = &arr[0]; //my0 is ptr to type "reg" and is assigned to addr of arr[0] which is of type "reg" too.
struct reg *my1 = &arr[1];

function pointers: http://denniskubes.com/2013/03/22/basics-of-function-pointers-in-c/
-----------------
function names actually refer to addr of func. So, we can have pointers to functions by using func name as addr (no need to use & with func name for addr).
char *pv=&v; => as explained above, this assigns pv to addr loc of variable v. *pv refers to contents of pv.
but for func, we need to have paranthesis around pointer. Also, instead of char, we need to have return val of func, and also need to provide all args of func (If no args, we can write "void" or leave it empty). i.e
void (*FuncPtr)() = HelloFunc; //Hellofunc is function defined with no i/p or o/p. OR
void (*FuncPtr)(void) = HelloFunc;
or:
void (*FuncPtr)(void); => define the ptr function
FuncPtr = HelloFunc; => assign ptr to addr of HelloFunc.

Now to reference any pointer value, we use *pv to read contents. (a=*pv reads contents of pv and stores in a). For function, we do the same, but we need to have *pv inside paranthesis to indicate it's a func. Also, we need (), since () operator is needed to call a function (with args in it if any). i.e
(*FuncPtr)(); //This calls the func HelloFunc() => equiv to calling HelloFunc(); directly.
FuncPtr(); //This also works and is exactly equiv to above line. This is since a func name (label) is converted to a pointer to itself. This means that func names can be used where function pointers are required as input. &func and *func are same and refer to func name, which is a pointer to itself. So, instead of using &func or *func, we should use func or func() directly

ex: (with args)
int (*FuncCalcPtr)(int, int) = FuncCalc; //or *FuncCalc, &FuncCalc, **FuncCalc all are same. FuncCalc fn is subtracts 2 int and returns an int.
int y = (*FuncCalcPtr)(10,2); //or FuncCalcPtr(10,2) is the same. returns 10-2=8, and stores it in y.

Func ptr can also be used as parameters to pass into another func. This is primary use of func ptr. ex:
int domath(int (*mathop)(int, int), int x, int y) {
  return (*mathop)(x, y);
}
in  main, do: int a = domath(add, 10, 2); //this calls domath func with ptr to "add" func.

typedef with pointers:
----
Above ex needed extra typing everytime fn ptr was defined. typedef can simplify this.
ex: Using typedef with pointers:
typedef int *intptr; => newptr is new alias with pointer type int*. "typedef int dist" creates "dist" as a synonym for int. similarly "intptr" is a synonym for "pointer pointing to int"
intptr ptr; => this defines a var "ptr" with type int. So, ptr is a pointer which can point to a memory with int type. We could have also written it as "int *ptr".

ex: Using typedef with fn pointers:
typedef int (*FuncCalcPtr_def)(int, int); => creates "FuncCalcPtr_def" as a synonym for a pointer to a fn of 2 int args that returns an int
FuncCalcPtr_def FuncCalcPtr; => this defines a var "FuncCalcPtr" with type "FuncCalcPtr_def", which is a ptr to fn. We could have written this as "int (*FuncCalcPtr)(int, int);

--------------------
size type:  http://www.acm.uiuc.edu/webmonkeys/book/c_guide/2.11.html
----------
size_t and ptrdiff_t were defined as separate type, since they are mem related. existing arithmetic types were deemed insufficient, since their size is defined according to the target processor's arithmetic capabilities, not the memory capabilities, such as available address space. Both of these types are defined in the stddef.h header as "typedef size_t", "typedef ptrdiff_t".

size_t: used to represent the size of any object (including arrays) in the particular implementation. It is used as the return type of the sizeof operator and is unsigned int.
ptrdiff_t:  used to represent the difference between pointers.

extended integer data type: *_t.
-------------------
to make code portable across diff OS, since existing int type have various sizes depending on system. The new types are especially useful in embedded environments where hardware supports usually only several types and that support varies from system to system. For ex: int N; may be 16 bit with certain complier/processor, while it may be 32 bit with other. Generally we don't care, but if these are being used in structure (as in MMIO), and we use a pointer to refer to various elements of that structure, then size of int does matter. One solution is to define new type as this:
typedef unsigned short uint16; => Here, we still need to know size of char,short,int,long on that complier/processor and modify this defn as needed.

an example depicting this problem is this:
typedef struct {
 volatile uint16_t CTRL1;           // control register
 volatile uint16_t CTRL2; }  CWT_TypeDef;
#define CWT                     ((volatile CWT_TypeDef*)  0x50000000  

Now in main.c, we do:
CWT->CTRL1=0x0012; CWT->CTRL2=0xFF55; => since compiler understands uint16_t to be of 2 bytes, it adds 2 to base addr to store CTRL2.
STRH     r0,[r1,#0];   => stores 0x0012 at base addr
STRH     r0,[r1,#0x2]; => stores 0xFF55 at base_addr+2

However, if we tried to use the same compiled code on some arch which had "unsigned short" implemented as 32 bits, then this code will incorrectly wrt 0x0012 into lower 2 bytes of CTRL1 and then 0xFF55 into upper 2 bytes of CTRL1. CTRL2 will not get written. In order to get rid of this problem, we have to change typedef in stdint.h to the correct 16bit integer and then we don't need to change our C code anywhere else. We recompile and generate correct binary for new arch. It saved us changing code from multiple places.

C99 std of ANSI-C, defined all additional data types as ending in _t, and user is asked not to define new types ending in _t. All new types are to be defined in inttypes.h header and also in stdint.h header by the compiler vendors. We can define types for exact width, least/max width type, etc. Exact width integer types are guaranteed to have the same number N of bits across all implementations. Included only if it is available in the implementation = intN_t, uintN_t. eg: uint8_t = unsigned 8-bit, uint32_t, etc.
sizeof() function can be used to find out the size of int, short, uint32_t, etc.

In cortex M0 stdint.h, int16_t is defined as type of "signed short int" =>  typedef signed short int int16_t;
similarly for uint8_t: typedef unsigned char uint8_t; => Note that in C, integers are represented in 16 bits or larger, so the only way to rep integer in 8 bits is by using signed/unsigned char.

---------------------
keywords & variables: http://www.acm.uiuc.edu/webmonkeys/book/c_guide/1.2.html#variables
---------------------
1. keywords: reserved keywords that can't be used as a variable identifier. ex: for, char, const, extern, etc.
---------
char short int long float double short signed unsigned => type and type specifier   
void
volatile const => type qualifier


2. variables: used to store values of a particular type
--------------------
names of identifiers: The use of two underscores (`__') in identifiers is reserved for the compiler's internal use according to the ANSI-C standard. Underscores (`_') are often used in names of library functions (such as "_main" and "_exit") and are reserved for libraries. In order to avoid collisions, do not begin an identifier with an underscore. Having __ both before and after variable name (eg __Symbol__) almost gurantees that there would be no name collision, as such identifiers with double underscores are extremely rare in user code.

A variable is defined by the following: <storage-class-specifier> <type-qualifier> <type-specifier> <type> variable-names,...
ex: extern const volatile unsigned long int rt_clk; => defines real time clk variable rt_clk

I. storage-class-specifier: storage class reflects data's lifespan during program execution.
1. typedef: The symbol name "variable-name" becomes a type-specifier of type "type-specifier". No variable is created.
ex: typedef long int mytype_t; => declares a new type mytype_t to be long int. From here on, we can use mytype_t instead of long int.
typedef most commonly used with struct to reduce cumbersome typing.
ex:
struct MyStruct {
    int data1;
    char data2;
};
with no typedef, we define var "a" of type Mystruct struct as follows: struct MyStruct a;
however with typedef, we can just define a new type as follows: typedef struct my_struct newtype;
or we can directly do typedef with struct defn as follows:
typedef struct  MyStruct {  
    int data1;
    char data2;
} newtype;
then we can define var "a" as being of type "newtype" as follows: newtype a;

2. extern: Indicates that the variable is defined outside of the current file. This brings the variables scope into the current scope. No variable is created.
3. static (permanent): Causes a variable that is defined within a function to be preserved in subsequent calls to the function. Variables declared outside the body of any function have global scope and static duration (for ex var declared outside main() are static, as they are not within any function). Although initial values may be assigned to global var, these are usually uninit. Since main() itself is a function, all var defined in it are local and auto, so we use "static" for these var to make them permanent. variables decalred outside main() are global for all functions in that file. static var are not released from mem on exit of function, so they consume mem space.
NOTE: we sometimes define function itself as "static".  In C, a static function is not visible outside of its translation unit, which is the object file it is compiled into. In other words, making a function static limits its scope. You can think of a static function as being "private" to its *.c file.
4. auto (temporary): Causes a local variable to have a local lifetime (default). Any variables declared within body of a function, including main(), have local scope and auto duration.
5. register: Requests that the variable be accessed as quickly as possible. This request is not guaranteed. Normally, the variable's value is kept within a CPU register for maximum speed.

II. type-qualifier: any declaration, inlcuding those of variables, struct/union, enum, etc can also have type-qualifier (volatile, auto) which qualifies the decl, instead of specifying it.
1. volatile: added to C pgm later. It causes the value to be fetched from memory every time it's referenced. It tells the compiler that the object is subject to sudden change for reasons which cannot be predicted from a study of the program itself, and forces every reference to such an object to be a genuine reference. This is used for defining variables stored in peripherals, so that uP doesn't read the variable from the register, which it might have stored a while back.
ex: volatile int j;

2. const: const means that something is not modifiable, so a data object that is declared with const as a part of its type specification must not be assigned to in any way during the run of a program.
ex: const int ci = 123; => declares a simple constant ci which always has a value of 123.
ex: const int *cpi; => declares a pointer "cpi" to a constant. cpi is an ordinary, modifiable pointer, but the thing that it points to must not be modified. comipler will check that cpi never points to something whose value changed.
ex: int *const cpi => declares a pointer "cpi" which is constant. It means that cpi is not to be modified, although whatever it points to can be modified \ the pointer is constant, not the thing that it points to.

III. type-specifier: void, all arithmetic types, boolean type, struct, etc.

3. enumerated tags:
-----------------

4. Arrays:
--------
array is defined as: <type-of-array> <name-of-array> [<number of elements in array>];
ex: int arr[10] => defines an array of 10 integers. Array elements are arr[0]. arr[1], ...  arr[9]. Each integer is 4 bytes (let's assume), so total size of array=4*10=40 bytes.

to initialize arrays:
we can either use for loop in main pgm, or init it at time of declaration.
int arr[] = {'1','2','3','4','5'}; => this init an array of 5 integers as follows: arr[0]=1, arr[1]=2 and so on. NOTE: there is no need to mention any value in the subscripts []. The size will automatically be calculated from the number of values. In this case, the size will be 5.
to init array with string 2 ways:
A. char arr[] = {'c','o','d','e','\0'};
B. char arr[] = "code"; => equiv to ex A above. We don't need an explicit null char here, since double quotes do that for us.

To access values in an array:
int j=arr[2]; => assigns j to arr[2] value which is 3.

We can also define array of structures, as well as array elements within structures.

5. structures and union:
----------------------
struct st{
    int a;
    char c[5];
};
int main()
{
    struct st st_arr[3]; // Declare an array of 3 structure objects
    struct st st_any[] = { {0,'c'},{1,'f'}}; //declares an array of 2 struct obj with values assigned    
    struct st st_obj0; // first structure object
    st_obj0.a = 0;
    st_obj0.c = 'a';
}

6. const:

7. strings: simply an array of characters encapsulated in double quotes. At the end of the string a null character is appended.
ex: char x="\x41" or "A" are the same string. x[0]=A, x[1]=null character.

8. define, ifdef: preprocessor that are remved by compiler depending on directive
#define NEW 0
#ifdef NEW => since NEW is defined this portion is kept by compiler
#define var ab
#else => this portion is removed by compiler
#define var cd
#endif

ex: this very commonly used in defines, so that we don't redefine something in multiple files
#ifndef CHAR_T => this piece of code can be placed in multiple files, but it will be compiled only from 1 file.
#define CHAR_T 0x45
#end
 
-----------------------------------

random number gen:
------------------
srand((unsigned) time(&t)); => inits rand num gen with time (in sec since epoch)
rand() % 50; => generates rand num b/w 0 to 49 using above seed. otherwise rand() will always gen same rand num seq since it will always use same seed (if we don't use srand).