Introduction to C Programming

"Hello, world" is not enough. Here are a list of programs to help get you up to speed on the general syntax and formatting of C.

Here is a list of programs that will help you learn C and its syntax fast.
###########################################################################
void main(void)
{

} ###########################################################################
int main()
{
return 0;
} ########################################################################### //================================================
// single line comments
//================================================
int main()
{
return 0;
}
########################################################################### /*================================================
encapsulated commenting
//================================================*/
int main()
{
return 0;
}

########################################################################### //================================================
// prints a string constant
//================================================
#include <stdio.h>

void main(void)
{
puts("Hello, Adam!");
}
########################################################################### //================================================
// prints the program name
//================================================
#include <stdio.h>

void main(int nArg, char** pArg)
{
puts(pArg[0]);
}
###########################################################################
//================================================
// integer declaration
//================================================
void main(void)
{
int n; // declaration of integer variable n
n = 123; // assignment to n

}
###########################################################################
//================================================
// printing an integer
//================================================
#include <stdio.h>

void main(void)
{
int n; // declaration of integer variable n
n = 12345; // assignment to n
printf("%d", n);

}
###########################################################################
//==========================================================
// addition-subtraction of integer variables
//==========================================================
#include <stdio.h>

void main(void)
{
int n, m, res; // declaration of integer variables
n = 123;
m = -20;
res = n+30;
printf("%d\n", res);
res = n+m;
printf("%d\n", res);
res = n-m;
printf("%d\n", res);
}
###########################################################################
//================================================
// multiplication-division of integers
//================================================
#include <stdio.h>

void main(void)
{
int n, m, res; // declaration of integer variables
n = 123;
m = -20;
res = n*30;
printf("%d\n", res);
res = 7/3;
printf("%d\n", res); // res==2
res = n*m;
printf("%d\n", res);
res = n/m;
printf("%d\n", res);
}
###########################################################################
//==========================================================
// reading integer value from console
//==========================================================
#include <stdio.h>
void main(void)
{
int n, m;

scanf("%d", &n);
printf("n=%d n*n=%d\n",n, n*n);

}
###########################################################################
//==========================================================
// float number variable declaration/assignment
//==========================================================
void main(void)
{
fload fNum;

fNum = 12.34567;

fNum = 1.234567E1;
}

###########################################################################
//==========================================================
// floating point arithmetic
//==========================================================
void main(void)
{
float fA, fB, fC;

fA = 1.2345;
fB = 9.8765;

fC = fA + fB;
fC = fA - fB;
fC = fA * fB;
fC = fA / fB;
}
###########################################################################
//==========================================================
// floating point different formats using for printing
//==========================================================
void main(void)
{
float fA;

fA = 19.2345;

printf(" f format: %f", fA);
printf(" 10.2f format: %10.2f", fA);
printf(" e format: %e", fA);
printf(" 10.4f format: %10.4f", fA);

}
###########################################################################
//==========================================================
// reading of float variable from console window
//==========================================================
void main(void)
{
float fA;

scanf("%f",&fA);
printf("%f %f %f\n", fA, fA*fA; 1.0/fA);

}

###########################################################################
//==========================================================
// check value of float point number
//==========================================================
void main(void)
{

float fA;

scanf("%f", &fA);

if(fA < 0.0)
{
printf("negative number\n");
}

}

###########################################################################
//==========================================================
// function without argument and without return value
//==========================================================
#include <stdio.h>

void Func1(void)
{
printf("Func1 inside");
}

void main(void)
{
Func1();
}

###########################################################################
//==========================================================
// function with argument and without return value
//==========================================================
#include <stdio.h>

void Func2(int n)
{
printf("Number inside = %d\n", n);
}

void main(void)
{
int k = 123456;
Func2(k);
}

###########################################################################
//==========================================================
// function without argument and with return value
//==========================================================
#include <stdio.h>

int Func3(void)
{
return 156789;
}

void main(void)
{
int k = 123456;
printf("%d ", k);
k = Func3();
printf("%d\n", k);
}

###########################################################################
//==========================================================
// function with argument and with return value
//==========================================================
#include <stdio.h>

int Func4(int m)
{
return m*m;
}

void main(void)
{
int k = 345;
int n;
n = Func4(k);
printf("%d %d\n", k, n);
}
###########################################################################
//==========================================================
// declaration and initialization of integer array
//==========================================================
#include <stdio.h>

void main(void)
{
int ar[8] = {0,1,2,3,40,50,60,7};

printf("%d %d %d %d %d\n", ar[0], ar[1], ar[2], ar[3], ar[4]);

ar[1] = 12345;
}
###########################################################################
//==========================================================
// while control operator
//==========================================================
void main(void)
{
int n=0;

while(n<10)
{
printf("%d\n", n);
n++;
}
}

###########################################################################
//==========================================================
// for loop control operator
//==========================================================
#include <stdio.h>

void main(void)
{
int i;
int s = 0;

for(i=0; i<21; i++)
{
s = s + i;
}
printf("%d\n", s);
}

###########################################################################
//==========================================================
// function assert for testing of logical condition
//==========================================================
#include <stdio.h>
#include

void main(void)
{
int n;

scanf("%d", &n);
assert(n);

scanf("%d", &n);
assert(n!=1);
}
###########################################################################
//==========================================================
// char variable as byte integer
//==========================================================
#include <stdio.h>
void main(void)
{
char n,m,k;

n=23; m=99;
k=n+m;
printf("%d\n",k);

n=85; m=99;
k=n+m;
printf("%d\n",k);
}
###########################################################################
//==========================================================
// char variable as character
//==========================================================
#include <stdio.h>
void main(void)
{
char c ='A';

printf("%c\n", c);

c='>';
printf("%c\n", c);
}

###########################################################################
//==========================================================
// print character table
//==========================================================
#include <stdio.h>
void main(void)
{
int i;
char c;

for(i=27; i<256; i++)
{
c=(char)i;
printf("%3d %c\n",i,c);
}
}
###########################################################################
//==========================================================
// reading of character from keyboard
//==========================================================
#include <stdio.h>

void main(void)
{
char cc;

scanf("%c", &cc);
printf(" %c\n",cc);
}

###########################################################################
//==========================================================
// char variable as set of bits: shift 1
//==========================================================
#include <stdio.h>
void main(void)
{
unsigned char b;

b = 1;

while(b <= 128 && b!=0)
{
printf("%d ", b);
b = b << 1;
}
}

###########################################################################
//==========================================================
// 64 bit integer long long
//==========================================================
#include <stdio.h>
void main(void)
{
long long nn;
unsigned long long mm;

nn = -122345678913;

mm = 1234567890987654;
}
###########################################################################
//==========================================================
// printing and reading of long long variables
//==========================================================
#include <stdio.h>

void main(void)
{
long long n;

scanf("%lld", &n);

printf("long long number = %lld\n", n);
}

###########################################################################
//==========================================================
// printing of factorial table
//==========================================================
#include <stdio.h>

void main(void)
{
int i;
unsigned long long nnF=1;

for(i=1; i<22; i++)
{
nnF = nnF*i;
printf("%3d %lld\n", i, nnF);
}
}
###########################################################################
//==========================================================
// string declarations and assignments
//==========================================================

void main(void)
{
char* pStr = "abcdef";
char str[10] = "ghijklmn";
}

###########################################################################
//==========================================================
// string output to console
//==========================================================
#include <stdio.h>

void main(void)
{
char* pStr = "abcdef";
char str[10] = "ghijklmn";
char st[5] ={'u', 'v', 'w', 'x', 0};

printf("%s\n", pStr);
printf("%s\n", str);
printf("%s\n", st);
}
###########################################################################
//==========================================================
// reading of the string
//==========================================================
#include <stdio.h>

void main(void)
{
char str[10];

scanf("%s", str);

printf("%s\n", str);
}
###########################################################################
//==========================================================
// control operator switch...case
//==========================================================
#include <stdio.h>

void main(void)
{
int n = 0;

while(n < 5)
{
switch(n)
{
case 0:
puts("zero");
break;
case 1:
puts("one");
break;
case 2:
puts("two");
break;
default:
puts("three or four");
}
n++;
}
}
###########################################################################
//==========================================================
// text file create
//==========================================================
#include <stdio.h>

void main(void)
{
FILE* pFile;

pFile = fopen("testfile.txt", "w");

fclose(pFile);
}
###########################################################################
//==========================================================
// writing to text file
//==========================================================
#include <stdio.h>

void main(void)
{
FILE* pFile;
int i;

pFile = fopen("testfile.txt", "w");

for(i=0; i<20; i++)
{
fprintf(pFile, "i= %d\n",i);
}

fclose(pFile);
}

###########################################################################
//==========================================================
// strings reading from text file
//==========================================================
#include <stdio.h>

void main(void)
{
FILE* pFile;
int i;
char str[257];

pFile = fopen("testfile.txt", "r");

for(i=0; i<10; i++)
{
fscanf(pFile, "%s", str);
printf("%s\n", str);
}

fclose(pFile);

}

###########################################################################
//==========================================================
// numbers reading from text file
//==========================================================
#include <stdio.h>

void main(void)
{
FILE* pFile;
int i;
int n;

pFile = fopen("numbers.txt", "r");

for(i=0; i<10; i++)
{
fscanf(pFile, "%d", &n);
printf("%d\n", n);
}

fclose(pFile);
}
###########################################################################
//==========================================================
// structure SPoint definition
//==========================================================
#include <stdio.h>

struct SPoint
{
float x;
float y;
};
void main(void)
{
struct SPoint pt = {1.5, 2.7};

printf("%f %f\n", pt.x, pt.y);
}

###########################################################################
//==========================================================
// structure SPerson definition
//==========================================================
#include <stdio.h>

struct SDate
{
short year;
unsigned char month;
unsigned char day;
};
struct SPerson
{ char surname[32];
char name[32];

char sex;

struct SDate birth;
};
void main(void)
{
struct SPerson pr = {"john", "dou", 'm', {1900,1,1} };

printf("%s %s %c %d %d %d\n", pr.surname, pr.name, pr.sex,
pr.birth.year, pr.birth.month, pr.birth.day);
}
###########################################################################
//==========================================================
// array of structure objects
//==========================================================
#include <stdio.h>

struct SPoint
{
float x;
float y;
};
void main(void)
{
struct SPoint curve[4] = { {0., 0.}, {0., 1.}, {1., 1.}, {1., 0.} };
int i;

for(i=0; i<4; i++)
{
printf("%f %f\n", curve[i].x, curve[i].y);
}
}

###########################################################################
//==========================================================
// typedef operator using
//==========================================================
#include <stdio.h>

typedef unsigned char byte;

void main(void)
{
byte b=1;

while(b!=0)
{
printf("%d ", b);
b++;
}
}
###########################################################################
//==========================================================
// enumerated data types
//==========================================================
#include <stdio.h>

enum color {black, red, green, blue, white};

void main(void)
{
enum color mycolor;

mycolor = blue;
printf("%d\n", mycolor);

mycolor = black;
printf("%d\n", mycolor);
}
###########################################################################
//==========================================================
// pointers to arrays
//==========================================================
#include <stdio.h>

void main(void)
{
int arr[5] = {10,20,30,40,50};
int i;

for(i=0; i<5; i++)
{
printf("address= %x value= %d\n", (arr+i), *(arr+i) );
}
}

###########################################################################
//==========================================================
// memory allocation
//==========================================================
#include <stdio.h>
#include <stdlib.h>

#define NSIZE 20

void main(void)
{
int* pN;
int i;

pN = (int*) malloc(NSIZE*sizeof(int));

for(i=0; i {
pN[i] = i*i;
}

for(i=0; i {
printf("%d %d\n", i, pN[i] );
}
}

###########################################################################
//==========================================================
// create pgm image file
//==========================================================
#include <stdio.h>
#include <stdlib.h>
void main(void)
{
int i;
int nW, nH;
unsigned char* pImg;
FILE* img_file= fopen("test.pgm", "wb");

nW = 512; nH = 512;
pImg = (unsigned char* ) malloc(nW*nH);

for(i=0;i {
pImg[i] = i % 256;
}

fprintf( img_file, "P5\n#\n%d %d\n255\n", nW, nH );

fwrite( pImg, 1, nW * nH, img_file);
fclose(img_file);
free(pImg);
}