C Is An Attitude

C is an attitude!

S. G. Ganesh G. R. Prakash

“C is clearly not the cleanest language ever designed nor the easiest to use, so why do many people use it?”

- Bjarne Stroustrup

Agenda • • • • • •

General Introduction Simple “Hello world” program Life time of C program Memory Organisation Dynamic Memory Allocation Some Interesting Problems

Open Sesame …

• • • • •

A brief history ANSI C Special Features Present Status Future of C

The evolution of C

Algol-60 CPL Algol-68 Pascal

BCPL B C ANSI C (C89) 1989 ANSI C (C9X)

C++

Life time of a C program

The main thing… • Significance of main – – – – – –

parameters are restricted ( 0/2/3 ) parameters passed from command line, declared by compiler and defined by user by convention a unique external function, implicit return 0 return type is always is an int

And now for something that is completely different…

# include <stdio.h> # include void main(){ char * message = “Hello world”; clrscr(); puts(message); }

# include void main(){ # include <stdio.h> char * message = “Hello world”; clrscr(); puts(message); }

# include void main(){ char * message = “Hello world”; # include <stdio.h> clrscr(); puts(message); }

# include void main(){ char * message = “Hello world”; clrscr(); # include <stdio.h> puts(message); }

# include void main(){ char * message = “Hello world”; clrscr(); puts(message); # include <stdio.h> }

# include void main(){ char * message = “Hello world”; clrscr(); puts(message); } # include <stdio.h>

# include <stdio.h> void main(){ char * message = “Hello world”; clrscr(); puts(message); } # include

// file header.h { if(1) printf(“This will always get printed”); else printf(“This will never get printed”); } // file myfile.c void main(){ # include “header.h” }

# include <stdio.h> # include void main(){ char * message = “Hello world”; clrscr(); printf(message); } printf(“%s”, message); char * message = “I got 50%discount”;

# include <stdio.h> # include void main(){ char * message = “Hello world”; clrscr(); printf(message+4); }

# include <stdio.h> # include void main(){ int * message = “Hello world”; clrscr(); printf(message+4); }

# include <stdio.h> # include void main(){ int number = “Hello world”; clrscr(); printf(“%s”, number +4 ); }

# include <stdio.h> # include void main(){ char * ptr = “Hello world”; char arr[] = “Hello world”; char confusion[] = {‘H’,’e’,’l’,..’d’,’\0’}; printf(“%d %d %d”,sizeof(ptr), sizeof(arr), strlen(confusion)); }

# include <stdio.h> # include void main(){ char arr1[12] = “Hello world”; char arr2[11] = “Hello world”; printf(“%s %s”, arr1, arr2); }

Where am I?

Command line arguments Stack free heap Initialized Data segment Initialized to Zero (BSS) Program Code

int initToZero1; static float initToZero2; FILE * initToZero3; double intitialized1 = 20.0; int main(){ size_t (*fp)(const char *) = strlen; char *dynamic = (char *)malloc(100); int stringLength; static int initToZero4; static int initialized2 = 10; strcpy(dynamic,”something”); stringLength = fp(dynamic); }

Allocate the Free; Free the allocated

• • • •

Memory Allocator in C malloc, calloc & free realloc realloc – Complete memory manager – – – –

as malloc as free as extender as shrinker

char *ptr=NULL; ptr = realloc(ptr,100); ptr = realloc(ptr, 250); ptr = realloc(ptr,100); ptr = realloc(ptr,0);

To Boggle your minds…

main() { int i; static int j; } Are the scope, visibility and life time of i & j are different?

char ch; for(ch=0;ch<=127;ch++) printf(“%c %d \n“, ch, ch);

main(){ int i= -3,j=i; i>>=2; i<<=2; if (i == j) printf(“U are smart”); else printf(“U are not smart enough”); }

int foo(int i) { static int j = foo(i); return j+1; } printf(“%d”, foo(5));

++variable++ char *p= "C always have someway around“; char *p1; p1=p; while(*p!='\0') ++*p++;

printf(“%d”, sizeof(32767)); printf(“%d”, sizeof(32768)); (1) 2. 32767 is in positive range of int, So it can be stored in an int. (2) 4. 32768 is beyond the positive range of int, it can’t be stored in an int. It requires long so it prints 4.

printf(“%d”, sizeof(-32767)); printf(“%d”, sizeof(-32768)); (1) 2. Both -32767 and +32767 are in valid range of int, so we cannot find out if it is a negative integer constant or a constant expression (2) 4. If –32768 were treated as negative integer constant it should have printed 2, because it is in valid integer range. +32768 cannot be represented so promoted to integer and – operator is applied on it. So the only possibility is that this is a constant expression. printf(“%d”, sizeof((int)-32768));

int i =10; if( (-i == ~i+1) && (-i == ~(i-1) ) printf(“Will this get printed.”); This shows the equivalence between these operators because of the simple reason that ~ produces ones' complement in twos' complement machines ~a = -1 ^ a the reason being that -1 is represented as all 1's and ex-or-ing it with the variable is same as ones compliment

#define DIM( array, type) \ sizeof(array)/sizeof(type) int size(int arr[]){ return sizeof( arr ) / sizeof( int );

} int arr[10]; printf(“%d”, DIM(arr, int)); printf(“%d”, size(arr));

Queries?

• It is flexible [to apply to any programming area]… • It is efficient [due to low-level semantics of the language]… • It is available [due to availability of C compilers in essentially every platform]… • It is portable [can be executed on multiple platforms, even though the language has many non-portable features]…”. - Bjarne Stroustrup