C

C Programming Language
C Programming Language (2nd Edition) (Prentice Hall Software) (Paperback)]
 * Note: The definitive C guide. Has   original example

C#
Are you looking for C Sharp?

Hello World
Hello world program - Wikipedia

main { printf("hello, world\n"); }

The C Programming Language (book) - Wikipedia
 * "Perhaps the most famous example program from the book is its "hello world" program, which just prints out the text "hello, world" to the terminal, as an illustration of a minimal working C program. Numerous texts since then have followed that convention for introducing a programming language."

gcc
See gcc

Hello World

 * 1) include 

int main { printf("Hello World\n"); return 0; }

Variables
int i = 1; float f = 1.0; char c = 'a'; char s[] = "Hello"; char *p = "Hi";

Print
printf("int:%d float:%.2f  char:%c  string:%s  string:%s", i, f, c, s, p);
 * 1) include 

Parameters
int main(int argc, char* argv[]) { int i;	printf("CMD Args: %d\n", argc); for(i = 0 ; i < argc ; i++) printf("CMD Arg %d = %s\n", i, argv[i]); // 0 = ./test }

Array
Basic int array, initialization and length
 * 1) include 

int main { // won't work for dymanic allocated memory #define ARRAY_LENGTH(x) (sizeof(x) / sizeof(x[0])) int int_array[10];// = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; // int int_array[10] = { 0 }; // all elements 0 // int array_length = sizeof(int_array) / sizeof(int_array[0]); int array_length = ARRAY_LENGTH(int_array); int i;	for (i = 0 ; i < array_length ; i++) int_array[i] = i;	// 40, 4, 10 printf("total length:%d, int size:%d,  array length:%d\n", sizeof(int_array), sizeof(int_array[0]), array_length); for (i = 0 ; i < array_length ; i++) printf("%d = %d\n", i, int_array[i]); }

Note: Arrays are passed as points to functions (Pass by Reference), so modifying an array within a function will modify the original.

Basic char array, initialization and length
 * 1) include 


 * 1) define ARRAY_LENGTH(x) (sizeof(x) / sizeof(x[0]))

int ord(char c) { return (unsigned char)c; } char chr(int n) { return (unsigned char)n; }

int main { int i;	// SEVERAL WAYS TO INITIALIZE: //char char_array[4] = {'O', 'O', 'O', '\0'}; //char char_array[4] = "OOO"; // don't forget ending \0 //char char_array[] = "OOO"; // size is 4 for \0 //char char_array[3]; //for (i = 0 ; i < ARRAY_LENGTH(char_array) ; i++) //	char_array[i] = 'O'; //char char_array[10] = { 0 }; // all elements 0 //char char_array[10] = {'O', 'O'}; // auto fills rest with \0, how nice, but can this be trusted? char char_array[10] = {[0 ... 9] = 'X'}; // All 'X'	// int array_length = sizeof(char_array) / sizeof(char_array[0]); int array_length = ARRAY_LENGTH(char_array); // 40, 1, 4	printf("total length:%d, char size:%d,  array length:%d\n", sizeof(char_array), sizeof(char_array[0]), array_length); for (i = 0 ; i < array_length ; i++) printf("%d = %c [%d][%d]\n", i, char_array[i], char_array[i], ord(char_array[i])); }

References:
 * How do I determine the size of my array in C? - Stack Overflow - http://stackoverflow.com/questions/37538/how-do-i-determine-the-size-of-my-array-in-c
 * Convert char to int in C and C++ - Stack Overflow - http://stackoverflow.com/questions/5029840/convert-char-to-int-in-c-and-c
 * How to initialize an array in C - Stack Overflow - http://stackoverflow.com/questions/201101/how-to-initialize-an-array-in-c

Random
FAQ > Generate random numbers? - Cprogramming.com
 * 1) include 
 * 2) include 
 * 3) include 

int main(void) { int i;  srand(time(NULL)); i = rand; printf ("Your random number is %d\n", i); printf ("This compiler can generate random numbers from 0 to %d\n", RAND_MAX); return(0); }

Get number between two numbers: /*  * Formula: *   rand % N   <- To get a number between 0 - N-1 *   Then add the result to min, giving you *   a random number between min - max. */   rc = (rand % (max - min + 1) + min);

Pointers
Simple int pointer: void mod_ptr(int *mptr) { printf("%d\n", *mptr); // 3

*mptr = 4; printf("%d\n", *mptr); // 4 int t = 5; *mptr = t;	printf("%d\n", *mptr); // 5 }

int main { int *ptr; *ptr = 1; printf("%d\n", *ptr); // 1 int tmp_num = 2; *ptr = tmp_num; // get value printf("%d\n", *ptr); // 2

int tmp_num = 2; ptr = &tmp_num; // get address printf("%d\n", *ptr); // 2

*ptr = 3; mod_ptr(ptr); printf("%d\n", *ptr); // 5

int n;	n = *ptr; printf("%d\n", n); // 5 }

References:
 * A Beginner's Guide to Pointers - CodeProject - http://www.codeproject.com/Articles/627/A-Beginner-s-Guide-to-Pointers
 * Pointers - C++ Documentation - http://www.cplusplus.com/doc/tutorial/pointers/

Function Pointers
References:
 * The Function Pointer Tutorials - Index - http://www.newty.de/fpt/index.html
 * Function pointer - Wikipedia, the free encyclopedia - https://en.wikipedia.org/wiki/Function_pointer

C for C++ Programmers
Source: C for C++ Programmers

Hello World

 * 1) include 

int main { printf("Hello World"); }

Output
printf("the variable 'i' is: %d", i);

sequence   type   : produces %d or %i - int    : signed decimal notation %s       - char * : prints characters until the null character is reached %x       - int    : hexidecimal notation %p       - void * : prints as a pointer

C++  C cin   stdin cout stdout cerr stderr

int fputs(const char *str, FILE *stream);

if ( (fputs("Hello world", stdout)) == EOF) { fprint(stderr, "Whoops, something went wrong"); }

Input
Input is a bit trickier. For reading an entire line you'll probably want to use fgets. Here's the prototype:

char *fgets(char *buffer, int size, FILE *stream);

fgets reads up to size-1 characters from stream and stores them in buffer. fgets stores the null character ('\0') after the last character read into the buffer and returns 'buffer' if everything works fine, or NULL on error or end of file. Here's an example:

char *cptr; char buffer[256]; printf("Enter some stuff:\n"); cptr = fgets(buffer, 256, stdin); if(cptr != NULL) { printf("You typed : %s\n", cptr); }

Command Line Arguments

 * 1) include 

int main(int argc, char *argv[]) { // argc - count of parameters, include program name // argv - array of arguments, argv[0] is program name if(argc == 2) { printf("Hello %s\n", argv[0]); } else { printf("Usage: %s [name]\n", argv[0]); } }

Memory Allocation
void * malloc(int nbytes)

/* We're going to allocate enough space for an integer and assign 5 to that memory location */ int *foo; /* malloc call: note the cast of the return value from a void * to the appropriate pointer type */ foo = (int *) malloc(sizeof(int)); *foo = 5;

/* Here we're allocating space for 5 integers */ int *foo; foo = (int *) malloc(sizeof(int) * 5); foo[0] = 17; foo[4] = 22;

void free(void *);

free(foo);


 * 1) define SIZE_N 1024*1024 // 1M
 * 2) define SIZE_M 256*37

... char *ptr; if( ( ptr = calloc( SIZE_N, SIZE_M ) ) == NULL ) { printf("Error allocating memory!\n"); exit(1); } ...  free(ptr);

Constants
#define MAX_LEN 1024 #define NUM_CALLS 20

structs
struct point { int x;   int y;  };

acceptable usage: struct point p; p.x = 0; p.y = 0;

preferred usage: struct point *p; p = (struct point *) malloc(sizeof(struct point)); p->x = 0; p->y = 0;

remove struct repetition with typedef: typdef struct point Point; Point *p; p = (Point *) malloc(sizeof(Point); p->x = 0;

Libraries
#include  #include 

printf formatting
%[flags][min field width][precision][length]conversion specifier - ---  -  -- ---   \             #,*        .#, .*     /             \    \                                 /               \   #,0,-,+, ,',I                 hh,h,l,ll,j,z,L    c,d,u,x,X,e,f,g,s,p,% -                ---    ---   # | Alternate,                 hh | char,           c | unsigned char, 0 | zero pad,                  h | short,          d | signed int, - | left align,                l | long,           u | unsigned int, + | explicit + - sign,        ll | long long,      x | unsigned hex int, | space for + sign,          j | [u]intmax_t,    X | unsigned HEX int, ' | locale thousands grouping, z | size_t,         e | [-]d.ddde±dd double, I | Use locale's alt digits    t | ptrdiff_t,      E | [-]d.dddE±dd double, L | long double, -===== if no precision  => 6 decimal places            /  f | [-]d.ddd double, if precision = 0 => 0 decimal places      _____/   g | e|f as appropriate, if precision = # => # decimal places               G | E|F as appropriate, if flag = #      => always show decimal point      s | string, ..............--                                           /          p | pointer, if precision     => max field width    /           % | %

Source: printf format specifications quick reference

More at: printf - C++ Reference

malloc vs calloc
Conceptually, calloc works like this: void *calloc ( size_t n, size_t size ) { void *mem = malloc ( n * size ); memset ( mem, 0, n * size ); return mem; }

Array of pointers
Array of pointers: void main { clrscr; char *array[2]; array[0]="Hello"; array[1]="World"; printf("The Array of String is = %s,%s\n", array[0], array[1]); getch; }
 * 1) include 
 * 2) include 

fork
if(fork) printf("I am the parent!"); /* A non-zero indicates the parent process */ else printf("I am the child!"); /* A zero indicates the child process */

Bloat Memory

 * 1) include 
 * 2) include 


 * 1) define BLOAT_ARRAY_SIZE 100000 // 10K
 * 2) define BLOAT_SIZE 1024*1024    // 1MB

typedef struct { char bloat[BLOAT_SIZE]; } bloat_struct;

int main { bloat_struct *bloat_array[BLOAT_ARRAY_SIZE]; // array of bloated structures

printf("Bloat Array Size: %d\n", BLOAT_ARRAY_SIZE); printf("Bloat Size: %d\n", BLOAT_SIZE);

int i, j; // loop variables for( i=0 ; i<BLOAT_ARRAY_SIZE ; i++ ) {

// allocate memory for bloated structure //if( ( bloat_array[i] = (bloat_struct *) malloc( sizeof(bloat_struct) ) ) == NULL ) if( ( bloat_array[i] = (bloat_struct *) calloc( sizeof(bloat_struct), 1 ) ) == NULL ) printf("Error allocating bloat: #%d\n", i);

// use allocated memory //for( j = 0 ; j<BLOAT_ARRAY_SIZE ; j++ ) //     bloat_array[i]->bloat[j] = '1'; }

printf("Memory has been consumed to %d * %d = %.0f bytes.\n",   BLOAT_SIZE, BLOAT_ARRAY_SIZE, (double) BLOAT_SIZE * BLOAT_ARRAY_SIZE); printf("Press enter to free the memory . . . ");

char *input; char buff[256]; input = fgets(buff, sizeof(buff), stdin);

// free allocated memory for( i=0 ; i<BLOAT_ARRAY_SIZE ; i++ ) { free(bloat_array[i]); }

return 0; }

Memory consumed: 1073741824

Press enter to free the memory. . . [root@adaptecweb ~]# gcc eatmem2.c -o eatmem2 ; if [ $? = 0 ] ; then ./eatmem2 ; fi
 * 1) include <stdio.h>
 * 2) include <stdlib.h>


 * 1) define BLOAT_ARRAY_SIZE 1024          // 1K
 * 2) define BLOAT_SIZE 1024*1024           // 1MB

int main { char *bloat_array[BLOAT_ARRAY_SIZE];   // array of pointers

char buff[1024];       // buffer for readline

printf("Object count: %d\n", BLOAT_ARRAY_SIZE); printf("Object size:: %d\n", BLOAT_SIZE); printf("Memory consumed: %.0f\n", (double) BLOAT_SIZE * BLOAT_ARRAY_SIZE); printf("\n");

int i, j;      // loop variables if( ( bloat_array[0] = calloc( BLOAT_SIZE, BLOAT_ARRAY_SIZE ) ) == NULL ) printf("Error!"); /* for( i=0 ; i<BLOAT_ARRAY_SIZE ; i++ ) { // allocate and zero fill memory for each object if( ( bloat_array[i] = calloc( BLOAT_SIZE, 1 ) ) == NULL ) printf("Error allocating memory! (#%d)\n", i); }       printf("Press enter to free the memory . . . "); fgets(buff, sizeof(buff), stdin);

free(bloat_array[0]); return 0;

// free allocated memory for( i=0 ; i<BLOAT_ARRAY_SIZE ; i++ ) { free(bloat_array[i]); }

//printf("Press enter to free the exit . . . "); //fgets(buff, sizeof(buff), stdin);

return 0; }


 * 1) include <stdio.h>
 * 2) include <stdlib.h>


 * 1) define BLOAT_ARRAY_SIZE 1024          // 1K
 * 2) define BLOAT_SIZE 1024*1024           // 1MB

int main { char *bloat_array[BLOAT_ARRAY_SIZE];   // array of pointers

char buff[1024];       // buffer for readline

printf("Object count: %d\n", BLOAT_ARRAY_SIZE); printf("Object size:: %d\n", BLOAT_SIZE); printf("Memory consumed: %.0f\n", (double) BLOAT_SIZE * BLOAT_ARRAY_SIZE); printf("\n");

int i, j;      // loop variables for( i=0 ; i<BLOAT_ARRAY_SIZE ; i++ ) { // allocate and zero fill memory for each object if( ( bloat_array[i] = calloc( BLOAT_SIZE, 1 ) ) == NULL ) printf("Error allocating memory! (#%d)\n", i); }

printf("Press enter to free the memory . . . "); fgets(buff, sizeof(buff), stdin);

// free allocated memory for( i=0 ; i<BLOAT_ARRAY_SIZE ; i++ ) { free(bloat_array[i]); }

//printf("Press enter to free the exit . . . "); //fgets(buff, sizeof(buff), stdin);

return 0; }


 * 1) include <stdio.h>
 * 2) include <stdlib.h>


 * 1) define SIZE_N 1024*1024 // 1M
 * 2) define SIZE_M 126*12

int main { char *ptr;

printf("Allocating %.0f bytes.\n", (double) SIZE_N * SIZE_M); if( ( ptr = calloc( SIZE_N, SIZE_M ) ) == NULL ) { printf("Error allocating memory!\n"); exit(1); }

printf("Press enter to free the memory . . . "); char buff[1024];       // buffer for readline fgets(buff, sizeof(buff), stdin);

// free allocated memory free(ptr);

return 0; }