├── 9781430259114.jpg ├── 9781430259114_Ch1 └── 9781430259114_Ch1 │ ├── add.asm │ ├── add.c │ ├── helloworld.c │ ├── main.c │ ├── main1.c │ └── test.c ├── 9781430259114_Ch2 └── 9781430259114_Ch2 │ ├── ptr1.c │ ├── ptr10.c │ ├── ptr2.c │ ├── ptr3.c │ ├── ptr4.c │ ├── ptr5.c │ ├── ptr6.c │ ├── ptr7.c │ ├── ptr8.c │ └── ptr9.c ├── 9781430259114_Ch3 └── 9781430259114_Ch3 │ ├── ptr1.c │ ├── ptr10.c │ ├── ptr11.c │ ├── ptr2.c │ ├── ptr3.c │ ├── ptr4.c │ ├── ptr5.c │ ├── ptr6.c │ ├── ptr7.c │ ├── ptr8.c │ └── ptr9.c ├── 9781430259114_Ch4 └── 9781430259114_Ch4 │ ├── string1.c │ ├── string10.c │ ├── string11.c │ ├── string12.c │ ├── string13.c │ ├── string2.c │ ├── string3.c │ ├── string4.c │ ├── string5.c │ ├── string6.txt │ ├── string7.c │ ├── string8.c │ └── string9.c ├── 9781430259114_Ch5 └── 9781430259114_Ch5 │ ├── MultiDim1.c │ ├── MultiDim10.c │ ├── MultiDim11.c │ ├── MultiDim12.c │ ├── MultiDim2.c │ ├── MultiDim3.c │ ├── MultiDim4.c │ ├── MultiDim5.c │ ├── MultiDim6.c │ ├── MultiDim7.c │ ├── MultiDim8.c │ └── MultiDim9.c ├── 9781430259114_Ch6 └── 9781430259114_Ch6 │ ├── struct1.c │ ├── struct10.c │ ├── struct11.c │ ├── struct12.c │ ├── struct13.c │ ├── struct14.c │ ├── struct15.c │ ├── struct16.c │ ├── struct17.c │ ├── struct2.c │ ├── struct3.c │ ├── struct4.c │ ├── struct5.c │ ├── struct6.c │ ├── struct7.c │ ├── struct8.c │ └── struct9.c ├── 9781430259114_Ch7 └── 9781430259114_Ch7 │ ├── Fptr1.c │ ├── Fptr2.c │ ├── Fptr3.c │ └── Fptr4.c ├── 9781430259114_Ch8 └── 9781430259114_Ch8 │ ├── client.c │ └── server.c ├── 9781430259114_Ch9 └── 9781430259114_Ch9 │ ├── Fileprog1.c │ ├── Fileprog10.c │ ├── Fileprog11.c │ ├── Fileprog12.c │ ├── Fileprog13.c │ ├── Fileprog2.c │ ├── Fileprog3.c │ ├── Fileprog4.c │ ├── Fileprog5.c │ ├── Fileprog6.c │ ├── Fileprog7.c │ ├── Fileprog8.c │ └── Fileprog9.c ├── LICENSE.txt ├── README.md └── contributing.md /9781430259114.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Apress/pointers-in-c/d4cde24c094fa61177367cc809ac4f1b77a46f28/9781430259114.jpg -------------------------------------------------------------------------------- /9781430259114_Ch1/9781430259114_Ch1/add.asm: -------------------------------------------------------------------------------- 1 | ; COMDAT ?add@@YAHHH@Z 2 | _TEXT SEGMENT 3 | _v1$ = 8 ; size = 4 4 | _v2$ = 12 ; size = 4 5 | ?add@@YAHHH@Z PROC ; add, COMDAT 6 | ; Line 7 7 | push ebp 8 | mov ebp, esp 9 | sub esp, 192 ; 000000c0H 10 | push ebx 11 | push esi 12 | push edi 13 | lea edi, DWORD PTR [ebp-192] 14 | mov ecx, 48 ; 00000030H 15 | mov eax, -858993460 ; ccccccccH 16 | rep stosd 17 | ; Line 8 18 | mov eax, DWORD PTR _v1$[ebp] 19 | add eax, DWORD PTR _v2$[ebp] 20 | ; Line 9 21 | pop edi 22 | pop esi 23 | pop ebx 24 | mov esp, ebp 25 | pop ebp 26 | ret 0 27 | -------------------------------------------------------------------------------- /9781430259114_Ch1/9781430259114_Ch1/add.c: -------------------------------------------------------------------------------- 1 | int add(int v1, int v2) 2 | { 3 | return v1+v2; 4 | } 5 | int main(int argc, char* argv[]) 6 | { 7 | int a = 10; 8 | int b = 20; 9 | int z = add(10,20); 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /9781430259114_Ch1/9781430259114_Ch1/helloworld.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main() 3 | { 4 | printf(“Hello World example\n”); 5 | return 0; 6 | } -------------------------------------------------------------------------------- /9781430259114_Ch1/9781430259114_Ch1/main.c: -------------------------------------------------------------------------------- 1 | static int staticglobal = 1; 2 | int initglobal = 10; 3 | int uninitglobal; 4 | void main() 5 | { 6 | return; 7 | } 8 | -------------------------------------------------------------------------------- /9781430259114_Ch1/9781430259114_Ch1/main1.c: -------------------------------------------------------------------------------- 1 | static int uninitstaticglbl; 2 | int uninitglobal; 3 | void main() 4 | { 5 | return; 6 | } 7 | -------------------------------------------------------------------------------- /9781430259114_Ch1/9781430259114_Ch1/test.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int glb_uninit; /* Part of BSS Segment -- global uninitialized variable, at runtime it is inizialzed to zero */ 4 | int glb_init = 10; /* Part of DATA Segment -- global initialized variable */ 5 | void foo(void) 6 | { 7 | static int num = 0; /* stack frame count */ 8 | int autovar; /* automatic variable/Local variable */ 9 | int *ptr_foo = (int*)malloc(sizeof(int)); 10 | if (++num == 4) /* Creating four stack frames */ 11 | return; 12 | printf("Stack frame number %d: address of autovar: %p\n", num, & autovar); 13 | printf("Address of heap allocated inside foo() %p\n",ptr_foo); 14 | foo(); /* function call */ 15 | } 16 | 17 | int main() 18 | { 19 | char *p, *b, *nb; 20 | int *ptr_main = (int*)malloc(sizeof(int)); 21 | printf("Text Segment:\n"); 22 | printf("Address of main: %p\n", main); 23 | printf("Address of afunc: %p\n",foo); 24 | printf("Stack Locations:\n"); 25 | foo(); 26 | printf("Data Segment:\n"); 27 | printf("Address of glb_init: %p\n", & glb_init); 28 | printf("BSS Segment:\n"); 29 | printf("Address of glb_uninit: %p\n", & glb_uninit); 30 | printf("Heap Segment:\n"); 31 | printf("Address of heap allocated inside main() %p\n",ptr_main); 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr1.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Apress/pointers-in-c/d4cde24c094fa61177367cc809ac4f1b77a46f28/9781430259114_Ch2/9781430259114_Ch2/ptr1.c -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr10.c: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | int num = 10; 4 | int *ptr = # 5 | int **mptr = &ptr; 6 | printf("Value of var num = %d\n", num); 7 | printf("Value of var num = %d\n", *ptr); 8 | printf("Value of var num = %d\n", **mptr); 9 | printf("Address of var num = %p\n", &num); 10 | printf("Address of var num = %p\n", ptr); 11 | printf("Address of var num = %p\n", *mptr); 12 | printf("Address of pointer var ptr = %p\n",&ptr); 13 | printf("Address of pointer var ptr = %p\n",mptr); 14 | printf("Address of pointer var mptr = %p\n",&mptr); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr2.c: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | int var_int = 40; 4 | printf (“Address of variable “var_int” %p\n”, &var_int); 5 | } -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr3.c: -------------------------------------------------------------------------------- 1 | struct node{ 2 | int a; 3 | int b; 4 | }; 5 | int main() 6 | { 7 | struct node p; 8 | printf("Address of node = %p\n",&p); 9 | printf("Address of member variable a = %p\n", &(p.a)); 10 | printf("Address of member variable b = %p\n", &(p.b)); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | char c_var; 6 | int i_var; 7 | double d_var; 8 | char *char_ptr; 9 | int *int_ptr; 10 | double *double_ptr; 11 | char_ptr = &c_var; 12 | int_ptr = &i_var; 13 | double_ptr = &d_var; 14 | printf("Size of char pointer = %d value = %u\n", sizeof(char_ptr), char_ptr); 15 | printf("Size of integer pointer = %d value = %u\n", sizeof(int_ptr), int_ptr); 16 | printf("Size of double pointer = %d value = %u\n", sizeof(double_ptr),double_ptr); 17 | getch(); 18 | } 19 | -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr5.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct inner_node 5 | { 6 | int in_a; 7 | int in_b; 8 | }; 9 | struct node{ 10 | int *a; 11 | int *b; 12 | struct inner_node* in_node; 13 | }; 14 | int main() 15 | { 16 | struct node *p; 17 | int *arrptr; 18 | int arr[10]; 19 | arrptr = arr; 20 | printf("Size of pointer variable (struct node*) = %d\n",sizeof(struct node*)); 21 | printf("Size of pointer variable pointing to int array = %d\n", sizeof(arrptr)); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr6.c: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | int num = 10; 4 | int* const ptr1 = # //Initialization of const ptr 5 | printf(“Value stored at pointer = %d\n”,*ptr1); 6 | } -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr7.c: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | int num1 = 10; 4 | int num2 = 20; 5 | int* const ptr1 = &num1; //Initialization of const ptr 6 | ptr1 = &num2; // can’t do this 7 | printf(“Value stored at pointer = %d\n”,*ptr1); 8 | } 9 | -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr8.c: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | int num1 = 10; 4 | const int* ptr1; 5 | int* ptr2; 6 | ptr1 = &num1; 7 | *ptr1 = 20; //can’t do this 8 | num1 = 20; //can be done 9 | printf(“Value stored at pointer = %d\n”,*ptr1); 10 | } 11 | -------------------------------------------------------------------------------- /9781430259114_Ch2/9781430259114_Ch2/ptr9.c: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | int num1 = 10; 4 | int num2 = 20; 5 | const int* ptr1 = &num1; 6 | int* ptr2; 7 | *ptr1 = 20; //can’t change the value what const pointer is pointing 8 | num1 = 20; //can be done 9 | ptr1 = &num2; //can’t change the constant pointer’s value (i.e – constant pointer should 10 | //not point to any other memory address once initialized 11 | printf(“Value stored at pointer = %d\n”,*ptr1); 12 | } -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr1.c: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | int iArray[32]; 4 | int i; 5 | for(i = 0; i<32; i++) 6 | { 7 | iArray[i] = i; 8 | } 9 | for(i = 0; i<32; i++) 10 | { 11 | printf("a[%d] %u %d ",i, &iArray[i], iArray[i]); 12 | if((i%4 == 0) && (i != 0)) 13 | printf("\n"); 14 | } 15 | getch(); 16 | } -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr10.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int arr[4] = {1,2,3,4}; 4 | int* arr_ptr[4]; 5 | int i; 6 | for(i = 0; i<4; i++) 7 | { 8 | arr_ptr[i] = arr + i; 9 | } 10 | printf("Address of (arr) array element\n"); 11 | for(i = 0; i<4; i++) 12 | { 13 | printf("Address of %d index = %p\n",i, arr + i); 14 | } 15 | printf("Value of (arr_ptr) array of pointer element \n"); 16 | for(i = 0; i<4; i++) 17 | { 18 | printf("Value of %d index = %p\n",i, arr_ptr[i]); 19 | } 20 | return 0; 21 | } -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr11.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int arr[4] = {1,2,3,4}; 4 | int (* ptr2arr)[4]; 5 | int i; 6 | int *ptr = arr; 7 | ptr2arr = &arr; 8 | for(i = 0; i<4; i++) 9 | { 10 | printf("address of array = %p\n", arr + i); 11 | } 12 | printf("Value at = %d\n",*(ptr2arr[0] + 1)); 13 | for(i = 0; i<4; i++) 14 | { 15 | printf("Value at %p = %d\n",(ptr2arr[0] + i),*(ptr2arr[0] + i)); 16 | } 17 | return 0; 18 | } -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define BIG_ENDIAN 0 3 | #define LITTLE_ENDIAN 1 4 | int endian() 5 | { 6 | short int word = 0x0001; 7 | char *byte = (char *) &word; 8 | return (byte[0] ? LITTLE_ENDIAN : BIG_ENDIAN); 9 | } 10 | int main(int argc, char* argv[]) 11 | { 12 | int value; 13 | value = endian(); 14 | if (value == 1) 15 | printf("The machine is Little endian %d\n",value); 16 | else 17 | printf("The machine is Big Endian %d\n",value); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr3.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int i = 0; 4 | int data = 9; 5 | int *iptr; 6 | char *cptr; 7 | iptr = &data; 8 | cptr = (char*)&data; 9 | printf("value of data = %d hex value = %x\n", data, data); 10 | printf("Address of data = %p\n", &data); 11 | printf("Integer pointer pointing at %p\n", iptr); 12 | printf("Character pointer pointing at %p\n", cptr); 13 | printf("Printing address of all the four bytes of variable int data\n"); 14 | for(i = 0;i<4;i++) 15 | { 16 | printf("address = %p value = %x\n",cptr, *cptr); 17 | cptr++; 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr4.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[4] = {1,2,3,4}; 4 | int *iptr1; 5 | int *iptr2; 6 | int val; 7 | iptr1 = &data[0]; 8 | iptr2 = &data[1]; 9 | val = iptr2 - iptr1; 10 | printf("Distance between two address = %d\n", val); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr5.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[4] = {1,2,3,4}; 4 | int *iptr1; 5 | int *iptr2; 6 | iptr1 = &data[0]; 7 | iptr2 = &data[1]; 8 | if(iptr1 == iptr2) 9 | printf("Address of iptr1 is equal to address of iptr2\n); 10 | if(iptr1 > iptr2) 11 | printf("Address of iptr1 is greater than address of iptr2\n”); 12 | else 13 | printf("Address of iptr1 is smaller than address of iptr2\n"); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr6.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int arr[4] = {1,2,3,4}; 4 | printf("Address of 0th index = %p\n", arr); 5 | printf("Address of 0th index = %p\n", &arr[0]); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr7.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int arr[4] = {1,2,3,4}; 4 | int *iptr; 5 | iptr = &arr[0] + 2; //pointing to second element 6 | printf("Address of 2nd index = %p\n", iptr); 7 | iptr = &arr[2]; //pointing to 2nd element 8 | printf("Address of 2nd index = %p\n", iptr); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr8.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int arr[4] = {1,2,3,4}; 4 | printf("Address of 0th index = %p\n", arr); 5 | printf("Address of 0th index = %p\n", &arr[0]); 6 | return 0; 7 | } 8 | -------------------------------------------------------------------------------- /9781430259114_Ch3/9781430259114_Ch3/ptr9.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int *ptr = NULL; 4 | static int count = 0; 5 | void insert(int data) 6 | { 7 | if(ptr == NULL) 8 | { 9 | ptr = (int*)malloc(sizeof(int)); //allocating space from heap for 1st data 10 | ptr[0] = data; //accessing memory address with array notation to store data 11 | } 12 | else 13 | { 14 | ptr = (int*)realloc(ptr, sizeof(int)*(count+1)); //Increasing the size of memory to 15 | //accomodate new integer 16 | ptr[count] = data; //accessing memory address with array notation to store data 17 | } 18 | count++; 19 | } 20 | 21 | void show() 22 | { 23 | int i = 0; 24 | for(i = 0; i< count; i++) 25 | { 26 | printf("%d\n", ptr[i]); 27 | } 28 | } 29 | 30 | int main(int argc, char* argv[]) 31 | { 32 | int c = 0; 33 | int data; 34 | while( c != 3 ) 35 | { 36 | printf("Insert choice\n"); 37 | printf("1 to insert data\n"); 38 | printf("2 to Show data\n"); 39 | printf("3 to quit data\n"); 40 | scanf("%d",&c); 41 | if( c == 3) 42 | break; 43 | switch(c) 44 | { 45 | case 1: 46 | printf("Data = \n"); 47 | scanf("%d",&data); 48 | insert(data); 49 | break; 50 | case 2: 51 | printf("Data in array\n"); 52 | show(); 53 | break; 54 | } 55 | } 56 | return 0; 57 | } 58 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string1.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char* argv[]) 3 | { 4 | char* str = "Hello Pointer"; 5 | int i = 0; 6 | for( i = 0; i< strlen(str); i++) 7 | { 8 | printf("%c",str[i]); 9 | } 10 | return 0; 11 | } -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string10.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | char arrstr[6]; 6 | char* strptr; 7 | printf(“Input hello\n”); 8 | scanf(“%s”, arrstr); 9 | strptr = arrstr; 10 | while(*strptr != ‘\0’) 11 | { 12 | printf(“%c”,*strptr); 13 | strptr++; 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string11.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | int main(int argc, char* argv[]) 3 | { 4 | char arr[6][10] = { EGRET", 5 | "IBIS", 6 | "MYNA", 7 | "IORA", 8 | "MUNIA", 9 | "BULBUL" 10 | }; 11 | int i; 12 | for(i = 0; i< 6; i++) 13 | { 14 | printf(" %d - %s\n", i, arr[i]); 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string12.c: -------------------------------------------------------------------------------- 1 | #include "stdafx.h" 2 | #include 3 | #include 4 | #include 5 | int main(int argc, char* argv[]) 6 | { 7 | char* arr[6]; 8 | char tempstring[30]; 9 | int i; 10 | for(i = 0 ; i< 6;i++) 11 | { 12 | printf("Insert data\n"); 13 | scanf("%s",tempstring); 14 | arr[i] = (char*)malloc(sizeof(char)*(strlen(tempstring) + 1)); 15 | strcpy(arr[i], tempstring); 16 | } 17 | printf(“Data in array”); 18 | for(i = 0; i< 6; i++) 19 | { 20 | printf(" %d - %s\n", i, arr[i]); 21 | } 22 | freestring(arr, 5); 23 | return 0; 24 | } 25 | freestring(char arr[], int length) 26 | { 27 | int i; 28 | for( i = 0; i <= length; i++) 29 | { 30 | free(arr[i]); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string13.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | int main(int argc, char* argv[]) 5 | { 6 | char** arr = NULL; 7 | char tempstring[30]; 8 | int i; 9 | for(i = 0 ; i< 6;i++) 10 | { 11 | printf("Insert data\n"); 12 | scanf("%s",tempstring); 13 | if(arr == NULL) 14 | { 15 | arr = (char**)malloc(sizeof(char*)); 16 | } 17 | else 18 | { 19 | arr = (char**)realloc(arr, sizeof(char*)*(i+1)); 20 | } 21 | arr[i] = (char*)malloc(sizeof(char)*(strlen(tempstring) + 1)); 22 | strcpy(arr[i], tempstring); 23 | } 24 | for(i = 0; i< 6; i++) 25 | { 26 | printf(" %d - %s\n", i, arr[i]); 27 | } 28 | freestrmemory(arr, 5); 29 | return 0; 30 | } 31 | void freestrmemory(char** arr, int length) 32 | { 33 | int i; 34 | for( i = 0; i<=length; i++) 35 | { 36 | free(arr[i]); 37 | } 38 | free(arr); 39 | } 40 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string2.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char* argv[]) 3 | { 4 | char* str = "Hello Pointer"; 5 | char* ptr = str; 6 | while(*ptr != '\0') 7 | { 8 | printf("%c",*ptr); //access characters 9 | ptr++; // traversing to next character position 10 | } 11 | return 0; 12 | } -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main(int argc, char* argv[]) 4 | { 5 | char* src = "Hello Pointer"; 6 | char* dst= NULL; 7 | dst = (char*)malloc(sizeof(char) * (strlen(src) + 1)); 8 | memcpy(dst,src, strlen(src)); 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string4.c: -------------------------------------------------------------------------------- 1 | int* foo(void); 2 | int main(int argc, char* argv[]) 3 | { 4 | int *m = foo(); 5 | printf("Printing local value of function foo = %d\n", *m); 6 | return 0; 7 | } 8 | int* foo(void) 9 | { 10 | int i = 10; 11 | return &i; \ 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string5.c: -------------------------------------------------------------------------------- 1 | char* foo(void); 2 | int main(int argc, char* argv[]) 3 | { 4 | char *m = foo(); 5 | printf("Printing local value of function foo = %s\n", m); 6 | return 0; 7 | } 8 | char* foo(void) 9 | { 10 | char* str = "STRING"; 11 | return str; 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string6.txt: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | char *strliteral = “ADD”; 4 | strliteral[0] = ‘B’; //Modifying value of 0th index, NOT ALLOWED, 5 | //program will generate segmentation fault 6 | strliteral++ ; //Allowed 7 | return 0; 8 | } -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string7.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | char arrstr[6]; 6 | char* strptr; 7 | printf(“Input hello\n”); 8 | scanf(“%s”, arrstr); 9 | strptr = (char*)malloc(sizeof(char)*10); 10 | printf(“Input hello\n”); 11 | scanf(“%s”, strptr); 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string8.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | char arrstr[6]; 6 | char* strptr; 7 | printf(“Input hello\n”); 8 | scanf(“%s”, arrstr); 9 | strptr = (char*)malloc(sizeof(char)*10); 10 | printf(“Input hello\n”); 11 | scanf(“%s”, strptr); 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch4/9781430259114_Ch4/string9.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | int main() 4 | { 5 | char arrstr[6]; 6 | char* strptr; 7 | printf(“Input hello\n”); 8 | scanf(“%s”, arrstr); 9 | printf(“String received = %s\n”,arrstr); 10 | } 11 | -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim1.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[5][5]; 4 | int i, j; 5 | for(i = 0; i<5;i++) 6 | { 7 | for(j = 0; j<5; j++) 8 | { 9 | data[i][j] = -1; 10 | } 11 | } 12 | return 0; 13 | } -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim10.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[3][3][3]; 4 | int i, j, k; 5 | int count = 0; 6 | for(i = 0; i<3;i++) 7 | { 8 | for(j = 0; j<3; j++) 9 | { 10 | for(k = 0; k <3; k++) 11 | { 12 | data[i][j][k] = count++; 13 | } 14 | } 15 | } 16 | for(i = 0; i<3;i++) 17 | { 18 | for(j = 0; j<3; j++) 19 | { 20 | for(k = 0; k <3; k++) 21 | { 22 | printf("%d%d%d=%d addr %p ", i,j,k, data[i][j][k],&data[i][j][k]); 23 | } 24 | printf("\n"); 25 | } 26 | printf("\n"); 27 | } 28 | for(i = 0; i<3; i++) 29 | { 30 | printf("row %d addr = %p\n",i, data[0][i]); 31 | } 32 | printf("2D row address\n"); 33 | for(i = 0; i<3; i++) 34 | { 35 | printf("3D %d ROW\n", i); 36 | for(j = 0; j<3; j++) 37 | { 38 | printf("2D row %d addr = %p %p \n",j, data[i][j], *(data[i] + j)); 39 | } 40 | } 41 | return 0; 42 | } -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim11.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[3][3][3]; 4 | int i, j, k; 5 | int count = 0; 6 | for(i = 0; i<3;i++) 7 | { 8 | for(j = 0; j<3; j++) 9 | { 10 | for(k = 0; k <3; k++) 11 | { 12 | data[i][j][k] = count++; 13 | } 14 | } 15 | } 16 | printf("Index=val addr <>\n"); 17 | for(i = 0; i<3;i++) 18 | { 19 | for(j = 0; j<3; j++) 20 | { 21 | for(k = 0; k <3; k++) 22 | { 23 | printf("%d%d%d=%d addr %p ", i,j,k, data[i][j][k],&data[i][j][k]); 24 | } 25 | printf("\n"); 26 | } 27 | printf("\n"); 28 | } 29 | for(i = 0; i<3; i++) 30 | { 31 | printf("row %d addr = %p\n",i, data[0][i]); 32 | } 33 | printf("2D row address\n"); 34 | for(i = 0; i<3; i++) 35 | { 36 | printf("3D %d ROW\n", i); 37 | for(j = 0; j<3; j++) 38 | { 39 | printf("2D row %d addr = %p %p \n",j, data[i][j], *(data[i] + j)); 40 | } 41 | } 42 | printf("1D element address\n"); 43 | for(i = 0; i<3; i++) 44 | { 45 | printf("3D %d ROW\n", i); 46 | for(j = 0; j<3; j++) 47 | { 48 | printf("2D %d row\n", j); 49 | for(k = 0; k<3; k++) 50 | { 51 | printf("%d%d%d = %p val = %d ",i,j,k, *(data[i] + j) + k, *(*(data[i] + j) +k)); 52 | } 53 | printf("\n"); 54 | } 55 | } 56 | return 0; 57 | } -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim12.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char* argv[]) 3 | { 4 | int data[3][3][3]; 5 | int i, j, k; 6 | int count = 0; 7 | int *dataptr = NULL; 8 | for(i = 0; i<3;i++) 9 | { 10 | for(j = 0; j<3; j++) 11 | { 12 | for(k = 0; k <3; k++) 13 | { 14 | data[i][j][k] = count++; 15 | } 16 | } 17 | } 18 | for(i = 0; i<3; i++) 19 | { 20 | printf("3D %d ROW\n", i); 21 | for(j = 0; j<3; j++) 22 | { 23 | printf("2D %d row\n", j); 24 | dataptr = *(data[i]+j); 25 | for(k = 0; k<3; k++) 26 | { 27 | printf("%d%d%d = %p val = %d ",i,j,k, dataptr, *dataptr++); 28 | } 29 | printf("\n"); 30 | } 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim2.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[5][5]; 4 | int i, j; 5 | int count = 0; 6 | for(i = 0; i<5;i++) 7 | { 8 | for(j = 0; j<5; j++) 9 | { 10 | data[i][j] = count++; 11 | } 12 | } 13 | printf(“Starting address of the array %p\n”, data); 14 | for(i = 0; i <5 ; i++) 15 | { 16 | printf(" %dth row location = %p\n", i, data[i]); 17 | printf(“Loc %d,1 = %p\n”, &data[i][0]); 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim3.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[5][5]; 4 | int i, j; 5 | int count = 0; 6 | for(i = 0; i<5;i++) 7 | { 8 | for(j = 0; j<5; j++) 9 | { 10 | data[i][j] = count++; 11 | } 12 | } 13 | for(i = 0; i<5;i++) 14 | { 15 | printf(" %d row = %p\n",i, data[i]); 16 | printf("Columns\n"); 17 | for(j = 0; j<5; j++) 18 | { 19 | printf("%d = %p, ",j, data[i] + j); 20 | } 21 | printf("\n"); 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim4.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[5][5]; 4 | int i, j; 5 | int count = 0; 6 | int (*aptr)[5]; 7 | for(i = 0; i<5;i++) 8 | { 9 | for(j = 0; j<5; j++) 10 | { 11 | data[i][j] = count++; 12 | } 13 | } 14 | aptr = data; 15 | for(i = 0; i <5 ; i++) 16 | { 17 | printf("%dth row = %p\n",i, *aptr++); 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim5.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[5][5]; 4 | int i, j; 5 | int count = 0; 6 | int (*aptr)[5]; 7 | for(i = 0; i<5;i++) 8 | { 9 | for(j = 0; j<5; j++) 10 | { 11 | data[i][j] = count++; 12 | } 13 | } 14 | aptr = data; 15 | for(i = 0; i <5 ; i++) 16 | { 17 | for(j = 0; j<5; j++) 18 | { 19 | printf("%d,%d = %p val = %d \n",i, j, (*aptr + j), *(*aptr + j)); 20 | } 21 | printf("\n"); 22 | aptr++; 23 | } 24 | return 0; 25 | } -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim6.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[5][5]; 4 | int i, j; 5 | int count = 0; 6 | int (*aptr)[5]; 7 | int *dataptr; 8 | for(i = 0; i<5;i++) 9 | { 10 | for(j = 0; j<5; j++) 11 | { 12 | data[i][j] = count++; 13 | } 14 | } 15 | aptr = data; 16 | for(i = 0; i <5 ; i++) 17 | { 18 | printf("Address of %d row = %p\n", i,(*aptr + i)); 19 | dataptr = (*aptr + i*5); 20 | for(j = 0; j<5; j++) 21 | { 22 | printf("%d,%d = %p val = %d \n",i, j, dataptr, *(dataptr)); 23 | dataptr++; 24 | } 25 | printf("\n"); 26 | } 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim7.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[3][3][3]; 4 | int i, j, k; 5 | int count = 0; 6 | for(i = 0; i<3;i++) 7 | { 8 | for(j = 0; j<3; j++) 9 | { 10 | for(k = 0; k <3; k++) 11 | { 12 | data[i][j][k] = count++; 13 | } 14 | } 15 | } 16 | for(i = 0; i <3 ; i++) 17 | { 18 | for(j = 0; j<3; j++) 19 | { 20 | for(k = 0; k <3; k++) 21 | { 22 | printf("%d%d%d= %d ",i,j,k,data[i][j][k]); 23 | } 24 | printf("\n"); 25 | } 26 | printf("\n"); 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim8.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[3][3][3]; 4 | int i, j, k; 5 | int count = 0; 6 | for(i = 0; i<3;i++) 7 | { 8 | for(j = 0; j<3; j++) 9 | { 10 | for(k = 0; k <3; k++) 11 | { 12 | data[i][j][k] = count++; 13 | } 14 | } 15 | } 16 | printf("0th row of 3d array = %p\n", data); 17 | printf("0th row of 2d array = %p\n", data[0][0]); 18 | printf("0th row of 1d array = %p\n", &data[0][0][0]); 19 | return 0; 20 | } -------------------------------------------------------------------------------- /9781430259114_Ch5/9781430259114_Ch5/MultiDim9.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | int data[3][3][3]; 4 | int i, j, k; 5 | int count = 0; 6 | for(i = 0; i<3;i++) 7 | { 8 | for(j = 0; j<3; j++) 9 | { 10 | for(k = 0; k <3; k++) 11 | { 12 | data[i][j][k] = count++; 13 | } 14 | } 15 | } 16 | for(i = 0; i<3;i++) 17 | { 18 | for(j = 0; j<3; j++) 19 | { 20 | for(k = 0; k <3; k++) 21 | { 22 | printf("%d%d%d=%d addr %p ", i,j,k, data[i][j][k],&data[i][j][k]); 23 | } 24 | printf("\n"); 25 | } 26 | printf("\n"); 27 | } 28 | printf(“Index value address\n”); 29 | for(i = 0; i<3; i++) 30 | { 31 | printf("row %d addr = %p\n",i, data+i); 32 | } 33 | return 0; 34 | } -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct1.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | struct date 4 | { 5 | int day; 6 | int month; 7 | int year; 8 | }; 9 | struct date current; 10 | current.day = 1; 11 | current.month = 11; 12 | current.year = 2012; 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct10.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | struct datawptr 4 | { 5 | int i; 6 | char *c; 7 | }; 8 | struct datawptr dptr1; 9 | struct datawptr dptr2; 10 | dptr1.i = 10; 11 | dptr1.c = (char*)malloc(sizeof(char)); 12 | *(dptr1.c) = 'c'; 13 | dptr2.c = (char*)malloc(sizeof(char)); 14 | memcpy(&dptr2, &dptr1, sizeof(struct datawptr)); 15 | printf("Int member value of 2nd variable = %d\n", dptr2.i); 16 | printf("Char ptr member value of 2nd varialbe = %c\n", *(dptr2.c)); 17 | printf("value of char ptr in 1st variable = %p\n", dptr1.c); 18 | printf("value of char ptr in 2nd variable = %p\n", dptr2.c); 19 | printf("Changing value of 2nd member in 2nd variable( dptr2 )\n"); 20 | *(dptr2.c) = 'a'; 21 | printf("value of char ptr of 2nd variable = %c and 1st variable = %c\n", *(dptr2.c),*(dptr1.c)); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct11.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char* argv[]) 3 | { 4 | struct data 5 | { 6 | int i; 7 | char c; 8 | int j; 9 | }; 10 | struct data *sptr; //pointer variable of type struct data 11 | struct data svar; // a normal variable of type struct data 12 | sptr = (struct data*) malloc (sizeof(struct data)); 13 | //below code is accessing the member fields with help of arrow operator -> 14 | sptr->c = 'c'; 15 | sptr->i = 10; 16 | sptr->j = 20; //or the same variable could be access in the following way 17 | (*sptr).c = 'd'; 18 | (*sptr).i = 30; 19 | (*sptr).j = 40; //below code is accessing the member fields with help of dot operator 20 | svar.c = 'a'; 21 | var.i = 1; 22 | svar.j = 2;//or the same variable could be access in the following way, using address 23 | // of operator and arrow operator 24 | (&svar)->c = 'c'; 25 | (&svar)->i = 3; 26 | (&svar)->j = 4; 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct12.c: -------------------------------------------------------------------------------- 1 | struct node 2 | { 3 | int data; 4 | char c; 5 | }; 6 | int main() 7 | { 8 | struct node v1; 9 | struct node* p1 = &v1; 10 | foo_passbyvalue( v1); 11 | foo_passbyaddr( p1 ); 12 | } 13 | void foo_passbyvalue(struct node v) 14 | { 15 | //do something 16 | } 17 | void foo_passbyaddr(struct node* p) 18 | { 19 | //do something 20 | } 21 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct13.c: -------------------------------------------------------------------------------- 1 | struct node 2 | { 3 | int data; 4 | }; 5 | void addnode(struct node* n1) 6 | { 7 | n1 = (struct node*)malloc(sizeof(struct node)); 8 | n1->data = 9; 9 | } 10 | int main(int argc, char* argv[]) 11 | { 12 | struct node* n1 = NULL; 13 | addnode(n1); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct14.c: -------------------------------------------------------------------------------- 1 | struct node 2 | { 3 | int data; 4 | }; 5 | void addnode(struct node** n1) 6 | { 7 | *n1 = (struct node*)malloc(sizeof(struct node)); 8 | (*n1)->data = 9; 9 | } 10 | int main(int argc, char* argv[]) 11 | { 12 | struct node* n1 = NULL; 13 | addnode(&n1); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct15.c: -------------------------------------------------------------------------------- 1 | int main() 2 | { 3 | struct signature 4 | { 5 | char sign; 6 | char version; 7 | }; 8 | struct id 9 | { 10 | char id; 11 | char platform; 12 | }; 13 | struct data 14 | { 15 | struct signature sig; 16 | struct id idv; 17 | char data[100]; 18 | }; 19 | struct data* img; 20 | recievedata(img); 21 | struct signature* sign = extractsignature( &img); 22 | struct id* idval = extractid( &img); 23 | } 24 | struct signature* extractsignature(struct data* d) 25 | { 26 | struct signature* sig = (struct signature*)d; 27 | return sig; 28 | } 29 | struct id* extracted( struct data* d) 30 | { 31 | struct id* idv = (struct id*)d; 32 | return idv; 33 | } 34 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct16.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | struct node 4 | { 5 | int data; 6 | struct node* next; 7 | }; 8 | 9 | struct node* createnode(int data) 10 | { 11 | struct node* n1 = (struct node*)malloc(sizeof(struct node)); 12 | n1->data = data; 13 | n1->next = NULL; 14 | return n1; 15 | } 16 | 17 | void addatend(struct node** root, struct node* n) 18 | { 19 | struct node* temp = *root; 20 | if(temp == NULL) 21 | { 22 | *root = n; 23 | } 24 | else 25 | { 26 | while(temp->next != NULL) 27 | temp = temp->next; 28 | temp->next = n; 29 | } 30 | } 31 | int main(int argc, char* argv[]) 32 | { 33 | struct node* root = NULL; 34 | for(int i = 0; i< 10;i++) 35 | { 36 | addatend(&root, createnode(i)); 37 | } 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct17.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | struct node 5 | { 6 | int data; 7 | struct node* left; 8 | struct node* right; 9 | }; 10 | 11 | struct node* createnode(int data) 12 | { 13 | struct node* n1 = (struct node*)malloc(sizeof(struct node)); 14 | n1->data = data; 15 | n1->left = NULL; 16 | n1->right = NULL; 17 | return n1; 18 | } 19 | void insertnode(struct node** root, struct node* n) 20 | { 21 | struct node* temp = *root; 22 | if(temp == NULL) 23 | { 24 | *root = n; 25 | } 26 | else 27 | { 28 | if(n->data < temp->data) 29 | { 30 | insertnode(&(temp->left), n); 31 | } 32 | else if( n->data > temp->data) 33 | { 34 | insertnode(&(temp->right), n); 35 | } 36 | } 37 | } 38 | int main(int argc, char* argv[]) 39 | { 40 | struct node* root = NULL; 41 | for(int i = 0; i< 10;i++) 42 | { 43 | insertnode(&root, createnode(i)); 44 | } 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct2.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | struct date 4 | { 5 | int day; 6 | int month; 7 | int year; 8 | }; 9 | struct date current = { 1, 11, 2012 }; 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct3.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char * argv[]) 2 | { 3 | struct header 4 | { 5 | int version; 6 | int signature; 7 | //below is structure variable definition and declaration 8 | struct tagname 9 | { 10 | int id; 11 | int offset; 12 | } tagid; 13 | }; 14 | struct header hdrinfo; 15 | hdrinfo.version = 0; 16 | hdrinfo.signature = 5; 17 | hdrinfo.tagid.id = 1; //accessing embedded variables through variable name 18 | hdrinfo.tagid.offset = 10; //accessing embedded variables through variable name 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct4.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char * argv[]) 2 | { 3 | struct data 4 | { 5 | int i; 6 | int j; 7 | int k; 8 | }; 9 | struct data v1; 10 | printf("Size of structure data = %d\n", sizeof(struct data)); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct5.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char * argv[]) 2 | { 3 | struct data 4 | { 5 | int i; 6 | int j; 7 | int k; 8 | }; 9 | struct data v1; 10 | printf("Size of structure data = %d\n", sizeof(struct data)); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct6.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char * argv[]) 2 | { 3 | struct data 4 | { 5 | int i; 6 | int j; 7 | int k; 8 | }; 9 | struct data v1; 10 | printf("Size of structure data = %d\n", sizeof(struct data)); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct7.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | struct gif_hdr 4 | { 5 | char signature[3]; 6 | char version[3]; 7 | int width; 8 | int height; 9 | char colormap; 10 | char bgcolor; 11 | char ratio; 12 | }; 13 | struct gif_hdr v1; 14 | struct gif_hdr *dsptr; 15 | printf("Size of structure data = %d\n", sizeof(struct gif_hdr)); 16 | dsptr = (struct gif_hdr*)malloc(sizeof(struct gif_hdr)); 17 | printf("Offset of signature = %d\n", &(dsptr->signature[0]) - &(dsptr->signature[0]) ); 18 | printf("Offset of version = %d\n", &(dsptr->version[0]) - &(dsptr->signature[0]) ); 19 | printf("Offset of width = %d\n", (char*)&(dsptr->width) - &(dsptr->signature[0])); 20 | printf("Offset of height = %d\n", (char*)&(dsptr->height) - &(dsptr->signature[0])); 21 | printf("Offset of colormap = %d\n", &(dsptr->colormap) - &(dsptr->signature[0])); 22 | printf("Offset of bgcolor = %d\n",&(dsptr->bgcolor) - &(dsptr->signature[0])); 23 | printf("Offset of ratio = %d\n", &(dsptr->ratio) - &(dsptr->signature[0])); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct8.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | struct gif_hdr 4 | { 5 | char signature[3]; 6 | char version[3]; 7 | int width; 8 | int height; 9 | char colormap; 10 | char bgcolor; 11 | char ratio; 12 | }; 13 | struct gif_hdr v1; 14 | struct gif_hdr *dsptr; 15 | printf("Size of structure data = %d\n", sizeof(struct gif_hdr)); 16 | dsptr = (struct gif_hdr*)malloc(sizeof(struct gif_hdr)); 17 | printf("Offset of signature = %d\n", &(dsptr->signature[0]) - &(dsptr->signature[0]) ); 18 | printf("Offset of version = %d\n", &(dsptr->version[0]) - &(dsptr->signature[0]) ); 19 | printf("Offset of width = %d\n", (char*)&(dsptr->width) - &(dsptr->signature[0])); 20 | printf("Offset of height = %d\n", (char*)&(dsptr->height) - &(dsptr->signature[0])); 21 | printf("Offset of colormap = %d\n", &(dsptr->colormap) - &(dsptr->signature[0])); 22 | printf("Offset of bgcolor = %d\n",&(dsptr->bgcolor) - &(dsptr->signature[0])); 23 | printf("Offset of ratio = %d\n", &(dsptr->ratio) - &(dsptr->signature[0])); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /9781430259114_Ch6/9781430259114_Ch6/struct9.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char* argv[]) 3 | { 4 | struct data 5 | { 6 | int i; 7 | char c; 8 | int j; 9 | int arr[2]; 10 | }; 11 | struct datawptr 12 | { 13 | int i; 14 | char *c; 15 | }; 16 | struct datawptr dptr1; 17 | struct datawptr dptr2; 18 | struct data svar1; // a normal variable of type struct data 19 | struct data svar2; // a normal variable of type struct data 20 | svar1.c = 'a'; 21 | svar1.i = 1; 22 | svar1.j = 2; 23 | svar1.arr[0] = 10; 24 | svar1.arr[1] = 20; 25 | svar2 = svar1; 26 | printf("Value of Second variable \n"); 27 | printf("Member c = %c\n", svar2.c); 28 | printf("Member i = %d\n", svar2.i); 29 | printf("Member j = %d\n", svar2.j); 30 | printf("Member arr0th = %d\n", svar2.arr[0]); 31 | printf("Member arr1st = %d\n", svar2.arr[1]); 32 | dptr1.i = 10; 33 | dptr1.c = (char*)malloc(sizeof(char)); 34 | *(dptr1.c) = 'c'; 35 | dptr2.c = (char*)malloc(sizeof(char)); 36 | dptr2 = dptr1; 37 | printf("int member = %d\n", dptr2.i); 38 | printf("char ptr member = %c\n", *(dptr2.c)); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /9781430259114_Ch7/9781430259114_Ch7/Fptr1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void mesg(int num ) 4 | { 5 | printf("Mesg no. %d\n", num); 6 | } 7 | int* add(int x, int y) 8 | { 9 | int *z = (int*)malloc(sizeof(int)); 10 | *z = 10; 11 | return z; 12 | } 13 | int main(int argc, char* argv[]) 14 | { 15 | int *t; 16 | void (*fpmsg)(int); //function pointer variable to point the function “mesg” 17 | int* (*addfptr)(int, int); //function pointer variable to point the function “add” 18 | addfptr = &add; //assignment using address of operator 19 | fpmsg = mesg; //assignment using implicit method 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /9781430259114_Ch7/9781430259114_Ch7/Fptr2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | void mesg(int num ) 4 | { 5 | printf("Mesg no. %d\n", num); 6 | } 7 | int main(int argc, char* argv[]) 8 | { 9 | int *t; 10 | void (*fpmsg1)(int); //function pointer variable to point the function “mesg” 11 | void (*fpmsg2)(int); //function pointer variable to point the function “mesg” 12 | fpmsg1 = mesg; 13 | fpmsg2 = mesg; 14 | fpmsg1( 10 ); // implicit method of invoking a function 15 | (*)fpmsg2( 20 ); // explicit way of invoking a function 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /9781430259114_Ch7/9781430259114_Ch7/Fptr3.c: -------------------------------------------------------------------------------- 1 | bool arraysearch(int data) 2 | { 3 | //some code 4 | return true; 5 | } 6 | bool linkedlistsearch(int data) 7 | { 8 | //some code 9 | return true; 10 | } 11 | 12 | bool binarysearch(int data) 13 | { 14 | //some code 15 | return true; 16 | } 17 | bool search( bool (*funcptr)( int ), int data ) 18 | { 19 | return (*funcptr)(data); 20 | } 21 | int main(int argc, char* argv[]) 22 | { 23 | printf("Input Options\n"); 24 | printf("1 arrsrch\n"); 25 | printf("2 linkedlistsrch\n"); 26 | printf("3 binarysrch\n"); 27 | printf("4 exit\n"); 28 | int choice = 0; 29 | int data; 30 | while(choice != 4) 31 | { 32 | printf("Input\n"); 33 | scanf("%d", &choice); 34 | printf("Data to search\n"); 35 | scanf("%d", &data); 36 | if(choice == 1) 37 | { 38 | search(arraysearch,data); //invoking 1st function 39 | } 40 | else if(choice == 2) 41 | { 42 | search(linkedlistsearch, data); //invoking 2nd function 43 | } 44 | else if(choice == 3) 45 | { 46 | search(binarysearch, data); //invoking 3rd function 47 | } 48 | else if(choice == 4) 49 | break; 50 | } 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /9781430259114_Ch7/9781430259114_Ch7/Fptr4.c: -------------------------------------------------------------------------------- 1 | int add( int a, int b) 2 | { 3 | int z = a + b ; 4 | return z; 5 | } 6 | int sub(int a, int b) 7 | { 8 | int z = a - b; 9 | return z; 10 | } 11 | int mul(int a, int b) 12 | { 13 | int z = a*b; 14 | return z; 15 | } 16 | int div(int a, int b) 17 | { 18 | int z = a/b; 19 | return z; 20 | } 21 | //array of function pointers, 22 | int (* opfunctptr [ ] ) ( int x, int y) = { add, sub, mul, div }; 23 | typedef int (*calc)(int x, int y ); 24 | //function returning the function pointer of type int (*calc)(int x, int y ) 25 | calc retmathfunc(int index) 26 | { 27 | return opfunctptr[index]; 28 | } 29 | int main(int argc, char* argv[]) 30 | { 31 | int choice, p1, p2, res; 32 | int (*calculator)(int x, int y); 33 | printf("Type -1 to quit\n"); 34 | printf("Type 0 - add, 1 - sub, 2 - mul, 3 - div\n"); 35 | scanf("%d", &choice); 36 | while( choice != -1) 37 | { 38 | calculator = retmathfunc(choice); //returns function pointer 39 | printf("Param1\n"); 40 | scanf("%d", &p1); 41 | printf("Param2\n"); 42 | scanf("%d", &p2); 43 | res = calculator(p1, p2); //calling function pointer 44 | printf("res = %d\n", res); 45 | printf("Type 0 - add, 1 - sub, 2 - mul, 3 - div\n"); 46 | scanf("%d", &choice); 47 | } 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /9781430259114_Ch8/9781430259114_Ch8/client.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #define PORT 3000 //Servers port 14 | #define MAXBUF 50 15 | 16 | int main(int argc, char* argv[]) 17 | { 18 | char buff[MAXBUF+1]; 19 | int len,sockfd; 20 | struct sockaddr_in serv; 21 | memset(&serv, '\0', sizeof(serv)); 22 | sockfd = socket(AF_INET, SOCK_STREAM, 0); 23 | serv.sin_family = AF_INET; 24 | serv.sin_port = htons(PORT); 25 | serv.sin_addr.s_addr = inet_addr("127.0.0.1");; 26 | 27 | connect(sockfd, (struct sockaddr*)&serv, sizeof(struct sockaddr)); 28 | len = recv(sockfd, buff, MAXBUF, 0); 29 | buff[len] = '\0'; 30 | printf("Received %s (%d bytes) \n", buff, len); 31 | close(sockfd); 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /9781430259114_Ch8/9781430259114_Ch8/server.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #define PORT 3000 //Servers port 14 | 15 | 16 | int main() 17 | { 18 | int sockfd; 19 | int res; 20 | struct sockaddr_in dest; 21 | struct sockaddr_in serv; 22 | int sin_size; 23 | socklen_t socksize = sizeof(struct sockaddr_in); 24 | memset(&serv, '\0', sizeof(serv)); 25 | 26 | serv.sin_family = AF_INET; 27 | serv.sin_port = htons(PORT); 28 | serv.sin_addr.s_addr = INADDR_ANY; 29 | 30 | sockfd = socket(AF_INET, SOCK_STREAM, 0); 31 | bind(sockfd, (struct sockaddr*)&serv, sizeof(struct sockaddr)); 32 | listen(sockfd, 1); 33 | res = accept(sockfd, (struct sockaddr*)&dest, &socksize); 34 | 35 | while(res) 36 | { 37 | printf("server: Recieved connection from %s\n", inet_ntoa(dest.sin_addr)); 38 | send(res, "Hello from server\n", 18, 0); 39 | res = accept(sockfd, (struct sockaddr*)&dest, &socksize); 40 | } 41 | close(res); 42 | close(sockfd); 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog1.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char* argv[]) 3 | { 4 | FILE* fp = NULL; 5 | fp = fopen("c:\\test.txt","w"); 6 | if(fp == NULL) 7 | { 8 | printf("File opening error\n"); 9 | } 10 | else 11 | { 12 | printf("File opening success\n"); 13 | } 14 | return 0; 15 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog10.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | FILE* fp; 4 | int res; 5 | int index; 6 | char* datafromfile = (char*)malloc(sizeof(char)*6); 7 | fp = fopen("c:\\test.txt","w"); 8 | if(fp == NULL) 9 | { 10 | printf("File opening error\n"); 11 | return 0; 12 | } 13 | else 14 | { 15 | printf("File opening success\n"); 16 | } 17 | fputs("HELLO NAV", fp); 18 | fclose(fp); 19 | fp = fopen("c:\\test.txt","r"); 20 | //Read the current content 21 | fgets(datafromfile, 10, fp); 22 | printf("Current content of file %s\n", datafromfile); 23 | rewind(fp); //resetting the file pointer 24 | fseek(fp, 6, SEEK_SET); //seeks file pointer to offset value 6 from beginning of file 25 | memset(datafromfile, 0, sizeof(char)); 26 | fgets(datafromfile, 6, fp); // 27 | printf("Content of data %s\n", datafromfile); 28 | fseek(fp, 0L, SEEK_SET); seeks file pointer to offset value 0 from beginning of file 29 | memset(datafromfile, 0, sizeof(char)); 30 | fgets(datafromfile, 6, fp); 31 | printf("Content of data %s\n", datafromfile); 32 | fclose(fp); 33 | return 0; 34 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog11.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | FILE* fp; 4 | int fileoffset = 0; 5 | fp = fopen("c:\\test.txt","w"); 6 | if(fp == NULL) 7 | { 8 | printf("File opening error\n"); 9 | return 0; 10 | } 11 | else 12 | { 13 | printf("File opening success\n"); 14 | } 15 | fputs("HELLO NAV", fp); 16 | fclose(fp); 17 | fp = fopen("c:\\test.txt","r"); 18 | fileoffset = ftell(fp); 19 | printf("File offset at default position %d\n", fileoffset); 20 | fseek(fp, 6, SEEK_SET); 21 | fileoffset = ftell(fp); 22 | printf("File offset after seeking %d\n", fileoffset); 23 | 24 | fclose(fp); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog12.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | FILE* fp; 4 | int fileoffset = 0; 5 | fp = fopen("c:\\test.txt","w"); 6 | if(fp == NULL) 7 | { 8 | printf("File opening error\n"); 9 | return 0; 10 | } 11 | else 12 | { 13 | printf("File opening success\n"); 14 | } 15 | fputs("HELLO NAV", fp); 16 | fclose(fp); 17 | fp = fopen("c:\\test.txt","r"); 18 | fseek(fp, 0, SEEK_END); 19 | fileoffset = ftell(fp); 20 | printf("Size of file in bytes %d\n", fileoffset); 21 | fclose(fp); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog13.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | FILE* fp; 4 | int fileoffset = 0; 5 | char* data = (char*)malloc(sizeof(char)*11); 6 | int val; 7 | fp = fopen("c:\\test.txt","r"); 8 | if(fp == NULL) 9 | { 10 | printf("File opening error\n"); 11 | return 0; 12 | } 13 | else 14 | { 15 | printf("File opening success\n"); 16 | } 17 | if(fgets(data, 10, fp)) 18 | { 19 | printf("%s \n",data); 20 | } 21 | else 22 | { 23 | printf("Line reading failure\n"); 24 | } 25 | rewind(fp); //resetting the file offset to the beginning of file 26 | while((val = fgetc(fp)) != EOF) 27 | { 28 | if(val != 10) //checking for new line 29 | { 30 | printf("%c",(char)val); 31 | } 32 | else 33 | { 34 | printf("\n"); 35 | } 36 | } 37 | fclose(fp); 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog2.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char* argv[]) 3 | { 4 | FILE* fp = NULL; 5 | int res; 6 | fp = fopen("c:\\test.txt","w"); 7 | if(fp == NULL) 8 | { 9 | printf("File opening error\n"); 10 | } 11 | else 12 | { 13 | printf("File opening success\n"); 14 | } 15 | res = fclose(fp); 16 | if(res == 0) 17 | { 18 | printf("File closed\n"); 19 | } 20 | else 21 | { 22 | printf("Unable to close file\n"); 23 | 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog3.c: -------------------------------------------------------------------------------- 1 | #include 2 | int main(int argc, char* argv[]) 3 | { 4 | FILE* fp; 5 | int res; 6 | int data; 7 | fp = fopen("c:\\test.txt","r"); 8 | if(fp == NULL) 9 | { 10 | printf("File opening error\n"); 11 | return 0; 12 | } 13 | else 14 | { 15 | printf("File opening success\n"); 16 | } 17 | while((data = fgetc(fp)) != EOF) 18 | { 19 | if ( data != 10) //checking for new line 20 | printf("%d %c ,", data, (char)data); 21 | else 22 | { 23 | printf{”\n”);} 24 | } 25 | } 26 | res = fclose(fp); 27 | if(res == 0) 28 | { 29 | printf("File closed\n"); 30 | } 31 | else 32 | { 33 | printf("Unable to close file\n"); 34 | } 35 | return 0; 36 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #define BUFFER 4 3 | int main(int argc, char * argv[]) 4 | { 5 | FILE* fp; 6 | int res; 7 | char*str = NULL; 8 | unsigned char chr; 9 | int fpos; 10 | fp = fopen("c:\\test.txt","r"); 11 | if(fp == NULL) 12 | { 13 | printf("File opening error\n"); 14 | } 15 | else 16 | { 17 | printf("File opening success\n"); 18 | } 19 | str = (char*)malloc(sizeof(char)*BUFFER); 20 | fpos = ftell(fp); 21 | printf("File pointer pos before reading = %d\n", fpos); 22 | if(fgets(str, BUFFER, fp)) 23 | { 24 | printf("%s \n",str); 25 | } 26 | else 27 | { 28 | printf("Line reading failure\n"); 29 | } 30 | fpos = ftell(fp); 31 | printf("File pointer pos after reading = %d\n", fpos); 32 | res = fclose(fp); 33 | if(res == 0) 34 | { 35 | printf("File closed\n"); 36 | } 37 | else 38 | { 39 | printf("Unable to close file\n"); 40 | } 41 | return 0; 42 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog5.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define BUFFER 5 4 | int main(int argc, char* argv[]) 5 | { 6 | FILE* fp; 7 | int res; 8 | char*str = NULL; 9 | fp = fopen("c:\\test.txt","r"); 10 | if(fp == NULL) 11 | { 12 | printf("File opening error\n"); 13 | } 14 | else 15 | { 16 | printf("File opening success\n"); 17 | } 18 | str = (char*)malloc(sizeof(char)*BUFFER); 19 | res = fread(str, sizeof(char), BUFFER-1, fp); 20 | str[4] = '\0'; 21 | if(res) 22 | { 23 | printf("%s \n",str); 24 | } 25 | else 26 | { 27 | printf("Line reading failure\n"); 28 | } 29 | res = fclose(fp); 30 | if(res == 0) 31 | { 32 | printf("File closed\n"); 33 | } 34 | else 35 | { 36 | printf("Unable to close file\n"); 37 | } 38 | return 0; 39 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog6.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | FILE* fp; 4 | int res; 5 | int index; 6 | char* name = NULL; 7 | char* country = NULL; 8 | fp = fopen("c:\\test.txt","r"); 9 | if(fp == NULL) 10 | { 11 | printf("File opening error\n"); 12 | } 13 | else 14 | { 15 | printf("File opening success\n"); 16 | } 17 | name = (char*)malloc(sizeof(char)*BUFFER); 18 | country = (char*)malloc(sizeof(char)*BUFFER); 19 | while (!feof(fp)) 20 | { 21 | fscanf(fp, "%d %s %s", &index, name, country); 22 | printf("%d %s %s\n", index, name, country); 23 | } 24 | res = fclose(fp); 25 | if(res == 0) 26 | { 27 | printf("File closed\n"); 28 | } 29 | else 30 | { 31 | printf("Unable to close file\n"); 32 | } 33 | return 0; 34 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog7.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | FILE* fp; 4 | int res; 5 | int index; 6 | char* namefmt = "First Middle Last"; 7 | fp = fopen("c:\\test.txt","w"); 8 | if(fp == NULL) 9 | { 10 | printf("File opening error\n"); 11 | return 0; 12 | } 13 | else 14 | { 15 | printf("File opening success\n"); 16 | } 17 | for( index = 0; index <= strlen(namefmt); index++) 18 | { 19 | fputc(namefmt[index], fp); 20 | } 21 | res = fclose(fp); 22 | if(res == 0) 23 | { 24 | printf("File closed\n"); 25 | } 26 | else 27 | { 28 | printf("Unable to close file\n"); 29 | } 30 | return 0; 31 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog8.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | FILE* fp; 4 | int res; 5 | int index; 6 | char* namefmt = "First Middle Last"; 7 | fp = fopen("c:\\test.txt","w"); 8 | if(fp == NULL) 9 | { 10 | printf("File opening error\n"); 11 | return 0; 12 | } 13 | else 14 | { 15 | printf("File opening success\n"); 16 | } 17 | fputs(namefmt, fp); 18 | res = fclose(fp); 19 | if(res == 0) 20 | { 21 | printf("File closed\n"); 22 | } 23 | else 24 | { 25 | printf("Unable to close file\n"); 26 | } 27 | return 0; 28 | } -------------------------------------------------------------------------------- /9781430259114_Ch9/9781430259114_Ch9/Fileprog9.c: -------------------------------------------------------------------------------- 1 | int main(int argc, char* argv[]) 2 | { 3 | FILE* fp; 4 | int res; 5 | int index; 6 | int numofdatatowrite; 7 | char* namefmt = "First Middle Last"; 8 | fp = fopen("c:\\test.txt","w"); 9 | if(fp == NULL) 10 | { 11 | printf("File opening error\n"); 12 | return 0; 13 | } 14 | else 15 | { 16 | printf("File opening success\n"); 17 | } 18 | numofdatatowrite = 5; 19 | if(numofdatatowrite == fwrite(namefmt, sizeof(char), numofdatatowrite, fp)) 20 | { 21 | printf("Success in writing data\n"); 22 | } 23 | else 24 | printf("Unsuccess in writing data\n"); 25 | res = fclose(fp); 26 | if(res == 0) 27 | { 28 | printf("File closed\n"); 29 | } 30 | else 31 | { 32 | printf("Unable to close file\n"); 33 | } 34 | return 0; 35 | } -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Apress/pointers-in-c/d4cde24c094fa61177367cc809ac4f1b77a46f28/LICENSE.txt -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Apress Source Code 2 | 3 | This repository accompanies [*Pointers in C*](http://www.apress.com/9781430259114) by Hrishikesh Dewan and Naveen Toppo (Apress, 2013). 4 | 5 | ![Cover image](9781430259114.jpg) 6 | 7 | Download the files as a zip using the green button, or clone the repository to your machine using Git. 8 | 9 | ## Releases 10 | 11 | Release v1.0 corresponds to the code in the published book, without corrections or updates. 12 | 13 | ## Contributions 14 | 15 | See the file Contributing.md for more information on how you can contribute to this repository. 16 | -------------------------------------------------------------------------------- /contributing.md: -------------------------------------------------------------------------------- 1 | # Contributing to Apress Source Code 2 | 3 | Copyright for Apress source code belongs to the author(s). However, under fair use you are encouraged to fork and contribute minor corrections and updates for the benefit of the author(s) and other readers. 4 | 5 | ## How to Contribute 6 | 7 | 1. Make sure you have a GitHub account. 8 | 2. Fork the repository for the relevant book. 9 | 3. Create a new branch on which to make your change, e.g. 10 | `git checkout -b my_code_contribution` 11 | 4. Commit your change. Include a commit message describing the correction. Please note that if your commit message is not clear, the correction will not be accepted. 12 | 5. Submit a pull request. 13 | 14 | Thank you for your contribution! --------------------------------------------------------------------------------