W3School C

www.w3cschool.cc

2014.11.3

C
C UNIX C
1972 DEC PDP-11
1978 Brian KernighanDennis Ritchie C
K&R
UNIX C UNIX C C

C
C UNIX
C B B 1970
C 1988 ANSI American National Standard
Institute
1973 UNIX C
C
C
Linux RBDMS MySQL C

C
C C
C C

C
C 3 ".c"
hello.c "vi""vim" C

C C

Windows NotepadOS Edit commandBriefEpsilon

EMACS vim/vi
Notepad Windows
vim/vi Windows Linux/UNIX
C
".c"

C
"" CPU

GNU C/C++ HP Solaris

GNU C/C++ C/C++

GNU gcc C C++

UNIX/Linux
Linux UNIX GCC
$ gcc -v

GNU
Using built-in specs.
Target: i386-redhat-linux
Configured with: ../configure --prefix=/usr .......
Thread model: posix
gcc version 4.1.2 20080704 (Red Hat 4.1.2-46)

GCC http://gcc.gnu.org/install/ GCC

Linux Cent OS Linux
Mac OS
Mac OS X GCC Xcode
Xcode GNU
Xcode developer.apple.com/technologies/tools/
Windows
Windows GCC MinGW MinGW MinGW
www.mingw.org MinGW MinGW MinGW<version>.exe
MinWG gcc-coregcc-g++binutils MinGW runtime

MinGW bin PATH

Windows gccg++arranlibdlltool GNU

C
C C

C Hello World
C

&

"Hello World"
#include <stdio.h>
int main()
{
/* C */
printf("Hello, World! \n");
return 0;
}

1. #include <stdio.h> C stdio.h

2. int main()
3. /*...*/
4. printf(...) C "Hello, World!"
5. return 0; main() 0

& C

1.
2. hello.c
3.
4. gcc hello.c
5. a.out
6. a.out
7. "Hello World"
$ gcc hello.c
$ ./a.out
Hello, World!

gcc hello.c

 C C

C Tokens
C
C
printf("Hello, World! \n");

printf
(
"Hello, World! \n"
)
;

;
C

printf("Hello, World! \n");

return 0;

C /* */
/* C */

C A-Z a-z
_ 0-9
C @$ %C C
Manpower manpower
mohd
myname50

zara
_temp

abc
j

move_name
a23b9

a_123
retVal

auto

else

long

switch

break

enum

register

typedef

case

extern

return

union

char

float

short

unsigned

const

for

signed

void

continue

goto

sizeof

volatile

default

if

static

while

do

int

struct

_Packed

double

C
C
C
int
int age;

int age

fruit = apples + oranges;

//

fruit = = apples

C
C

void
void

char

1 byte

-128 127 0 255

unsigned
char

1 byte

0 255

signed char

1 byte

-128 127

int

24
bytes

-32,768 32,767 -2,147,483,648

2,147,483,647

unsigned int

24
bytes

0 65,535 0 4,294,967,295

short

2 bytes

-32,768 32,767

unsigned
short

2 bytes

0 65,535

long

4 bytes

-2,147,483,648 2,147,483,647

unsigned
long

4 bytes

0 4,294,967,295

sizeof
sizeof(type) int
#include <stdio.h>
#include <limits.h>

int main()
{
printf("Storage size for int : %d \n", sizeof(int));
return 0;
}

Linux
Storage size for int : 4

float

4 byte

1.2E-38 3.4E+38

double

8 byte

2.3E-308 1.7E+308

15

long double

10 byte

3.4E-4932 1.1E+4932

19

float.h

#include <stdio.h>
#include <float.h>
int main()
{
printf("Storage size for float : %d \n", sizeof(float));
printf("Minimum float positive value: %E\n", FLT_MIN );
printf("Maximum float positive value: %E\n", FLT_MAX );
printf("Precision value: %d\n", FLT_DIG );
return 0;
}

Linux
Storage size for float : 4
Minimum float positive value: 1.175494E-38
Maximum float positive value: 3.402823E+38
Precision value: 6

void
void

C
void exit (int status);

C void int
rand(void);

void
void * void
*malloc( size_t size ); void

void

C
C

char

int

float

double

void

type variable_list;

type C charw_charintfloatdoublebool
variable_list

int
char
float
double

i, j, k;
c, ch;
f, salary;
d;

int i, j, k; ij k int ijk

type variable_name = value;

extern int d = 3, f = 5;
int d = 3, f = 5;
byte z = 22;
char x = 'x';

//
//
//
//

d f
d f
z
x 'x'

NULL 0

extern

#include <stdio.h>
//
extern int a, b;
extern int c;
extern float f;
int main ()
{

/* */
int a, b;
int c;
float f;
/* */
a = 10;
b = 20;
c = a + b;
printf("value of c : %d \n", c);
f = 70.0/3.0;
printf("value of f : %f \n", f);
return 0;
}

value of c : 30
value of f : 23.333334

//
int func();
int main()
{
//
int i = func();
}
//
int func()
{
return 0;
}

C LvaluesRvalues
C
1. lvaluelvalue

2. rvaluervalue

int g = 20;

10 = 20;

0x 0X 0

U L U unsignedL
longU L

212
215u
0xFeeL
078
032UU

/*
/*
/*
/*
/*

*/
*/
*/
8 */
*/

85
0213
0x4b
30
30u
30l
30ul

/*
/*
/*
/*
/*
/*
/*

*/
*/
*/
*/
*/
*/
*/

e E

3.14159
314159E-5L
510E
210f
.e55

/*
/*
/*
/*
/*

*/
*/
*/
*/
*/

'x' char
'x' '\t'
'\u02C0'
C
\n\t

\\

\'

'

\"

"

\?

\a

\b

\f

\n

\r

\t

\v

\ooo

\xhh . . .

#include <stdio.h>
int main()
{
printf("Hello\tWorld\n\n");
return 0;
}

Hello

World

""

"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"

C
1. #define
2. const
#define
#define
#define identifier value

#include <stdio.h>

#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main()
{
int area;
area = LENGTH * WIDTH;
printf("value of area : %d", area);
printf("%c", NEWLINE);
return 0;
}

value of area : 50

const
const
const type variable = value;

#include <stdio.h>
int main()
{
const int LENGTH = 10;
const int WIDTH = 5;
const char NEWLINE = '\n';
int area;
area = LENGTH * WIDTH;
printf("value of area : %d", area);
printf("%c", NEWLINE);
return 0;
}

value of area : 50

C
C /
C
auto
register
static
extern

auto
auto
{
int mount;
auto int month;
}

auto auto

register
register RAM
'&'
{
register int

miles;

'register'

static
static
static
static static

C static
#include <stdio.h>
/* */
void func(void);

static int count = 5; /* */

main()
{
while(count--)
{
func();
}
return 0;
}
/* */
void func( void )
{
static int i = 5; /* */
i++;
printf("i is %d and count is %d\n", i, count);
}

i
i
i
i
i

is
is
is
is
is

6 and count is 4
7 and count is 3
8 and count is 2
9 and count is 1
10 and count is 0

extern
extern 'extern'

extern extern

extern
main.c
#include <stdio.h>
int count ;
extern void write_extern();
main()

{
count = 5;
write_extern();
}

support.c
#include <stdio.h>
extern int count;
void write_extern(void)
{
printf("count is %d\n", count);
}

extern main.c count

$gcc main.c support.c

a.out
5

C
C

C A 10 B 20

A + B 30

A - B -10

A * B 200

B / A 2

B % A 0

++

A++ 11

--

A-- 9

C
#include <stdio.h>
main()
{
int a = 21;
int b = 10;
int c ;
c = a + b;
printf("Line
c = a - b;
printf("Line
c = a * b;
printf("Line
c = a / b;
printf("Line
c = a % b;
printf("Line
c = a++;
printf("Line
c = a--;
printf("Line

1 - c %d\n", c );
2 - c %d\n", c );
3 - c %d\n", c );
4 - c %d\n", c );
5 - c %d\n", c );
6 - c %d\n", c );
7 - c %d\n", c );

Line
Line
Line
Line
Line
Line
Line

1
2
3
4
5
6
7

c
c
c
c
c
c
c

31
11
210
2
1
21
22


C A 10 B 20

==

(A == B)

!=

(A != B)

>

(A > B)

<

(A < B)

>=

(A >= B)

<=

(A <= B)

C
#include <stdio.h>
main()
{
int a = 21;
int b = 10;
int c ;
if( a == b )
{
printf("Line
}
else
{
printf("Line
}
if ( a < b )
{
printf("Line
}
else
{
printf("Line

1 - a b\n" );

1 - a b\n" );

2 - a b\n" );

2 - a b\n" );

}
if ( a > b )
{
printf("Line 3 - a
}
else
{
printf("Line 3 - a
}
/* a b */
a = 5;
b = 20;
if ( a <= b )
{
printf("Line 4 - a
}
if ( b >= a )
{
printf("Line 5 - b
}

b\n" );

b\n" );

b\n" );

b\n" );

Line
Line
Line
Line
Line

1
2
3
4
5

a
a
a
a
b

b
b
b
b
b

C A 1 B 0

&&

(A && B)

||

(A || B)

!(A && B)

#include <stdio.h>
main()
{
int a = 5;
int b = 20;
int c ;
if ( a && b )
{
printf("Line 1 - \n" );
}
if ( a || b )
{
printf("Line 2 - \n" );
}
/* a b */
a = 0;
b = 10;
if ( a && b )
{
printf("Line 3 - \n" );
}
else
{
printf("Line 3 - \n" );
}
if ( !(a && b) )
{
printf("Line 4 - \n" );
}
}

Line
Line
Line
Line

1
2
3
4

& | ^

p&q

p|q

p^q

A = 60 B = 13
A = 0011 1100
B = 0000 1101
----------------A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
C A 60 B 13

&

AND

(A & B) 12
0000 1100

OR

(A | B) 61
0011 1101

(A ^ B) 49
0011 0001

"
"

(~A ) -61
1100 00112

<<

A << 2 240
1111 0000

>>

A >> 2 15
0000 1111

C
#include <stdio.h>
main()

{
unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 = 0000 1101 */
int c = 0;
c = a & b;
/* 12 = 0000 1100 */
printf("Line 1 - c %d\n", c );
c = a | b;
/* 61 = 0011 1101 */
printf("Line 2 - c %d\n", c );
c = a ^ b;
/* 49 = 0011 0001 */
printf("Line 3 - c %d\n", c );
c = ~a;
/*-61 = 1100 0011 */
printf("Line 4 - c %d\n", c );
c = a << 2;
/* 240 = 1111 0000 */
printf("Line 5 - c %d\n", c );
c = a >> 2;
/* 15 = 0000 1111 */
printf("Line 6 - c %d\n", c );
}

Line
Line
Line
Line
Line
Line

1
2
3
4
5
6

c
c
c
c
c
c

12
61
49
-61
240
15

C = A + B A + B
C

+=

C += A C = C + A

-=

C -= A C = C - A

*=

C *= A C = C * A

/=

C /= A C = C / A

%=

C %= A C = C % A

<<=

C <<= 2 C = C <<
2

>>=

C >>= 2 C = C >>
2

&=

C &= 2 C = C & 2

^=

C ^= 2 C = C ^ 2

|=

C |= 2 C = C | 2

C
#include <stdio.h>
main()
{
int a = 21;
int c ;
c = a;
printf("Line 1 - =

c = %d\n", c );

c += a;
printf("Line 2 - += c = %d\n", c );
c -= a;
printf("Line 3 - -= c = %d\n", c );
c *= a;
printf("Line 4 - *= c = %d\n", c );
c /= a;
printf("Line 5 - /= c = %d\n", c );
c = 200;
c %= a;
printf("Line 6 - %= c = %d\n", c );
c <<= 2;
printf("Line 7 - <<= c = %d\n", c );

c >>= 2;
printf("Line 8 - >>= c = %d\n", c );
c &= 2;
printf("Line 9 - &= c = %d\n", c );
c ^= 2;
printf("Line 10 - ^= c = %d\n", c );
c |= 2;
printf("Line 11 - |= c = %d\n", c );
}

Line
Line
Line
Line
Line
Line
Line
Line
Line
Line
Line

1 - = c = 21
2 - += c = 42
3 - -= c = 21
4 - *= c = 441
5 - /= c = 21
6 - %= c = 11
7 - <<= c = 44
8 - >>= c = 11
9 - &= c = 2
10 - ^= c = 0
11 - |= c = 2

? sizeof &
C sizeof ? :

sizeof()

sizeof(a) 4
a

&

&a;

*a;

?:

?
X : Y

#include <stdio.h>
main()
{
int a = 4;
short b;
double c;
int* ptr;
/* sizeof */
printf("Line 1 - a = %d\n", sizeof(a) );
printf("Line 2 - b = %d\n", sizeof(b) );
printf("Line 3 - c = %d\n", sizeof(c) );
/* & * */
ptr = &a;
/* 'ptr' 'a' */
printf("a %d\n", a);
printf("*ptr %d\n", *ptr);
/* */
a = 10;
b = (a == 1) ? 20: 30;
printf( "b %d\n", b );
b = (a == 10) ? 20: 30;
printf( "b %d\n", b );
}

a 4
*ptr 4
b 30
b 20

x = 7 + 3 * 2x 13 20 * +
3*2 7

() [] -> . ++ - -

+ - ! ~ ++ - - (type)* & sizeof

*/%

+-

<< >>

< <= > >=

== !=

AND

&

XOR

OR

AND

&&

OR

||

?:

= += -= *= /= %=>>= <<= &= ^= |=

C
#include <stdio.h>
main()
{
int
int
int
int
int

a =
b =
c =
d =
e;

20;
10;
15;
5;

e = (a + b) * c / d;
// ( 30 * 15 ) / 5
printf("(a + b) * c / d %d\n", e );
e = ((a + b) * c) / d;
// (30 * 15 ) / 5
printf("((a + b) * c) / d %d\n" , e );
e = (a + b) * (c / d);
// (30) * (15/5)
printf("(a + b) * (c / d) %d\n", e );
e = a + (b * c) / d;
// 20 + (150/5)
printf("a + (b * c) / d %d\n" , e );

return 0;
}

(a + b) * c / d 90
((a + b) * c) / d 90
(a + b) * (c / d) 90
a + (b * c) / d 50

C true null false

if

if

if...else

if else else

 if

if else if if
else if

switch

switch

switch

switch switch

? :
? : if...else
Exp1 ? Exp2 : Exp3;

Exp1Exp2 Exp3
? Exp1 Exp1 Exp2 ?
Exp1 Exp3 ?

while

for

do...while

while

whilefor do..while

break

loop switch loop

switch

continue

goto

goto

for

#include <stdio.h>
int main ()
{
for( ; ; )
{
printf("This loop will run forever.\n");

}
return 0;
}

C
for(;;)
Ctrl + C

C
C main()

C strcat()
memcpy()

C
return_type function_name( parameter list )
{
body of the function
}

C
return_type
return_type void

max() num1 num2

/* */

int max(int num1, int num2)

{
/* */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}

return_type function_name( parameter list );

max()
int max(int num1, int num2);

int max(int, int);

#include <stdio.h>
/* */
int max(int num1, int num2);
int main ()
{
/* */

int a = 100;
int b = 200;
int ret;
/* */
ret = max(a, b);
printf( "Max value is : %d\n", ret );
return 0;
}
/* */
int max(int num1, int num2)
{
/* */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}

max() main()
Max value is : 200

C
C

1.
2.
3.

ab c main()

#include <stdio.h>
int main ()
{
/* */
int a, b;
int c;
/* */
a = 10;
b = 20;
c = a + b;
printf ("value of a = %d, b = %d and c = %d\n", a, b, c);
return 0;
}

#include <stdio.h>
/* */
int g;

int main ()
{
/* */
int a, b;
/* */
a = 10;
b = 20;
g = a + b;
printf ("value of a = %d, b = %d and g = %d\n", a, b, g);
return 0;
}

#include <stdio.h>
/* */
int g = 20;
int main ()
{
/* */
int g = 10;
printf ("value of g = %d\n",

g);

return 0;
}

value of g = 10

#include <stdio.h>
/* */
int a = 20;
int main ()
{
/* */

int a = 10;
int b = 20;
int c = 0;
printf ("value of a in main() = %d\n",
c = sum( a, b);
printf ("value of c in main() = %d\n",

a);
c);

return 0;
}
/* */
int sum(int a, int b)
{
printf ("value of a in sum() = %d\n",
printf ("value of b in sum() = %d\n",

a);
b);

return a + b;
}

value
value
value
value

of
of
of
of

a
a
b
c

in
in
in
in

main() = 10
sum() = 10
sum() = 20
main() = 30

int

char

'\0'

float

double

pointer

NULL

number0number1...number99
numbers numbers[0]numbers[1]...numbers[99]

C
type arrayName [ arraySize ];

arraySize type C
double 10 balance
double balance[10];

balance 10 double

C
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

{ } [ ]

double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

balance[4] = 50.0;

50.0 0
1

double salary = balance[9];

10 salary

#include <stdio.h>
int main ()
{
int n[ 10 ]; /* n 10 */
int i,j;
/* */
for ( i = 0; i < 10; i++ )
{
n[ i ] = i + 100; /* i i + 100 */
}
/* */
for (j = 0; j < 10; j++ )
{
printf("Element[%d] = %d\n", j, n[j] );
}
return 0;
}

Element[0]
Element[1]
Element[2]
Element[3]
Element[4]
Element[5]
Element[6]
Element[7]
Element[8]
Element[9]

=
=
=
=
=
=
=
=
=
=

100
101
102
103
104
105
106
107
108
109

C
C C

C
C C
C

&

#include <stdio.h>
int main ()
{
int var1;
char var2[10];
printf("Address of var1 variable: %x\n", &var1
printf("Address of var2 variable: %x\n", &var2

);
);

return 0;
}

Address of var1 variable: bff5a400

Address of var2 variable: bff5a3f6

type *var-name;

type C var-name
*

int
double
float
char

*ip;
*dp;
*fp;
*ch

/*
/*
/*
/*

*/
double */
*/
*/

#include <stdio.h>
int main ()
{
int var = 20;
int *ip;
ip = &var;

/* */
/* */

/* var */

printf("Address of var variable: %x\n", &var

);

/* */
printf("Address stored in ip variable: %x\n", ip );
/* */
printf("Value of *ip variable: %d\n", *ip );
return 0;
}

Address of var variable: bffd8b3c

Address stored in ip variable: bffd8b3c

Value of *ip variable: 20

C NULL
NULL
NULL
NULL
#include <stdio.h>
int main ()
{
int *ptr = NULL;
printf("The value of ptr is : %x\n", ptr

);

return 0;
}

The value of ptr is 0

0
0 NULL

if
if(ptr)
if(!ptr)

/* p */
/* p */

C
C C

++--+-

C
C null '\0' null

"Hello"
"Hello"
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

char greeting[] = "Hello";

C/C++

null C '\0'

#include <stdio.h>
int main ()
{
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
printf("Greeting message: %s\n", greeting );
return 0;
}

Greeting message: Hello

&
strcpy(s1, s2);
s2 s1
strcat(s1, s2);

s2 s1

strlen(s1);
s1

strcmp(s1, s2);
,s1 s2 0 s1<s2 0 s1>s2
0

strchr(s1, ch);
s1 ch

strstr(s1, s2);
s1 s2

#include <stdio.h>
#include <string.h>
int main ()
{
char str1[12] = "Hello";
char str2[12] = "World";
char str3[12];
int len ;
/* str1 str3 */
strcpy(str3, str1);
printf("strcpy( str3, str1) :

%s\n", str3 );

/* str1 str2 */
strcat( str1, str2);
printf("strcat( str1, str2):

%s\n", str1 );

/* str1 */
len = strlen(str1);
printf("strlen(str1) : %d\n", len );
return 0;
}

strcpy( str3, str1) :

strcat( str1, str2):
strlen(str1) : 10

Hello
HelloWorld

C
C C

Title
Author
Subject
Book ID

struct struct struct

struct [structure tag]

{
member definition;
member definition;
...
member definition;
} [one or more structure variables];

structure tag member definition int i; float f;

Book
struct Books
{
char title[50];
char author[50];
char subject[100];
int
book_id;
} book;

.
struct

#include <stdio.h>
#include <string.h>
struct Books

{
char
char
char
int

title[50];
author[50];
subject[100];
book_id;

};
int main( )
{
struct Books Book1;
struct Books Book2;

/* Book1 Book */
/* Book2 Book */

/* Book1 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/*
printf(
printf(
printf(
printf(

Book1
"Book
"Book
"Book
"Book

*/
1 title : %s\n", Book1.title);
1 author : %s\n", Book1.author);
1 subject : %s\n", Book1.subject);
1 book_id : %d\n", Book1.book_id);

/*
printf(
printf(
printf(
printf(

Book2
"Book
"Book
"Book
"Book

*/
2 title : %s\n", Book2.title);
2 author : %s\n", Book2.author);
2 subject : %s\n", Book2.subject);
2 book_id : %d\n", Book2.book_id);

return 0;
}

Book
Book
Book
Book
Book
Book
Book
Book

1
1
1
1
2
2
2
2

title : C Programming
author : Nuha Ali
subject : C Programming Tutorial
book_id : 6495407
title : Telecom Billing
author : Zara Ali
subject : Telecom Billing Tutorial
book_id : 6495700

#include <stdio.h>
#include <string.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int
book_id;
};
/* */
void printBook( struct Books book );
int main( )
{
struct Books Book1;
/* Book1 Book */
struct Books Book2;
/* Book2 Book */
/* Book1 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* Book1 */
printBook( Book1 );
/* Book2 */
printBook( Book2 );
return 0;
}
void printBook( struct Books book )
{
printf( "Book title : %s\n", book.title);
printf( "Book author : %s\n", book.author);
printf( "Book subject : %s\n", book.subject);
printf( "Book book_id : %d\n", book.book_id);
}


Book
Book
Book
Book
Book
Book
Book
Book

title : C Programming
author : Nuha Ali
subject : C Programming Tutorial
book_id : 6495407
title : Telecom Billing
author : Zara Ali
subject : Telecom Billing Tutorial
book_id : 6495700

struct Books *struct_pointer;

&

struct_pointer = &Book1;

->
struct_pointer->title;

#include <stdio.h>
#include <string.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int
book_id;
};
/* */
void printBook( struct Books *book );
int main( )
{
struct Books Book1;
/* Book1 Book */
struct Books Book2;
/* Book2 Book */
/* Book1 */
strcpy( Book1.title, "C Programming");

strcpy( Book1.author, "Nuha Ali");

strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* Book1 Book1 */
printBook( &Book1 );
/* Book2 Book2 */
printBook( &Book2 );
return 0;
}
void printBook( struct Books *book )
{
printf( "Book title : %s\n", book->title);
printf( "Book author : %s\n", book->author);
printf( "Book subject : %s\n", book->subject);
printf( "Book book_id : %d\n", book->book_id);
}

Book
Book
Book
Book
Book
Book
Book
Book

title : C Programming
author : Nuha Ali
subject : C Programming Tutorial
book_id : 6495407
title : Telecom Billing
author : Zara Ali
subject : Telecom Billing Tutorial
book_id : 6495700

0 1 1 C
""""
""

1 0 1
9

struct
{ };

struct bs{
int a:8;
int b:2;
int c:6;
};

struct bs{
int a:8;
int b:2;
int c:6;
}data;

data bs a 8 b 2 c 6

struct packed_struct {
unsigned int f1:1;
unsigned int f2:1;
unsigned int f3:1;
unsigned int f4:1;
unsigned int type:4;
unsigned int my_int:9;
} pack;

packed_struct 6 1 f1..f4 4 type 9

my_int

struct bs{
unsigned a:4;
unsigned :4;
unsigned b:4;
unsigned c:4
}

/* */
/* */

a 4 4 0 b 4
c 4
8

struct k{
int a:1;
int :2;
int b:3;
int c:2;
};

/* 2 */

main(){
struct bs{
unsigned a:1;
unsigned b:3;
unsigned c:4;
} bit,*pbit;
bit.a=1;
/* */
bit.b=7;
/* */
bit.c=15;
/* */
printf("%d,%d,%d\n",bit.a,bit.b,bit.c);
/* */
pbit=&bit; /* bit pbit */
pbit->a=0; /* a 0 */
pbit->b&=3; /* "&="pbit->b=pbit->b&3 b 7 3
pbit->c|=1; /* "|="pbit->c=pbit->c|1 15 */
printf("%d,%d,%d\n",pbit->a,pbit->b,pbit->c);
/* */

bs abc bs bit bs
pbit

union union
union
union [union tag]
{
member definition;
member definition;
...
member definition;
} [one or more union variables];

union tag member definition int i; float f;

Data if str
union Data
{
int i;
float f;
char str[20];
} data;

Data

Data 20

#include <stdio.h>
#include <string.h>

union Data
{
int i;
float f;
char str[20];
};
int main( )
{
union Data data;
printf( "Memory size occupied by data : %d\n", sizeof(data));
return 0;
}

Memory size occupied by data : 20

.
union

#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
{
union Data data;
data.i = 10;
data.f = 220.5;
strcpy( data.str, "C Programming");
printf( "data.i : %d\n", data.i);
printf( "data.f : %f\n", data.f);
printf( "data.str : %s\n", data.str);
return 0;
}


data.i : 1917853763
data.f : 4122360580327794860452759994368.000000
data.str : C Programming

i f
str

#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
{
union Data data;
data.i = 10;
printf( "data.i : %d\n", data.i);
data.f = 220.5;
printf( "data.f : %f\n", data.f);
strcpy( data.str, "C Programming");
printf( "data.str : %s\n", data.str);
return 0;
}

data.i : 10
data.f : 220.500000
data.str : C Programming

C
TRUE/FALSE

struct
{
unsigned int widthValidated;
unsigned int heightValidated;
} status;

8 0 1C

struct
{
unsigned int widthValidated : 1;
unsigned int heightValidated : 1;
} status;

status 4 2
32 1 status 4
33 33 8

#include <stdio.h>
#include <string.h>
/* */
struct
{
unsigned int widthValidated;
unsigned int heightValidated;
} status1;
/* */
struct
{
unsigned int widthValidated : 1;
unsigned int heightValidated : 1;
} status2;
int main( )
{
printf( "Memory size occupied by status1 : %d\n", sizeof(status1));
printf( "Memory size occupied by status2 : %d\n", sizeof(status2));
return 0;
}

Memory size occupied by status1 : 8

Memory size occupied by status2 : 4

struct
{
type [member_name] : width ;
};

type

member_name

width

1 0 7
3
struct
{
unsigned int age : 3;
} Age;

C age 3 3

#include <stdio.h>
#include <string.h>
struct
{
unsigned int age : 3;
} Age;
int main( )
{
Age.age = 4;
printf( "Sizeof( Age ) : %d\n", sizeof(Age) );
printf( "Age.age : %d\n", Age.age );
Age.age = 7;
printf( "Age.age : %d\n", Age.age );

Age.age = 8;
printf( "Age.age : %d\n", Age.age );
return 0;
}

Sizeof(
Age.age
Age.age
Age.age

Age ) : 4
: 4
: 7
: 0

C typedef
C typedef
BYTE
typedef unsigned char BYTE;

BYTE unsigned char

BYTE

b1, b2;

typedef unsigned char byte;

typedef
typedef
#include <stdio.h>
#include <string.h>
typedef struct Books
{
char title[50];
char author[50];
char subject[100];
int
book_id;
} Book;
int main( )
{
Book book;

strcpy( book.title, "C Programming");

strcpy( book.author, "Nuha Ali");
strcpy( book.subject, "C Programming Tutorial");
book.book_id = 6495407;
printf(
printf(
printf(
printf(

"Book
"Book
"Book
"Book

title : %s\n", book.title);

author : %s\n", book.author);
subject : %s\n", book.subject);
book_id : %d\n", book.book_id);

return 0;
}

Book
Book
Book
Book

title : C Programming
author : Nuha Ali
subject : C Programming Tutorial
book_id : 6495407

typedef vs #define
#define C typedef
typedef #define
1 ONE
typedef #define
#define
#include <stdio.h>
#define TRUE 1
#define FALSE 0
int main( )
{
printf( "Value of TRUE : %d\n", TRUE);
printf( "Value of FALSE : %d\n", FALSE);
return 0;
}

Value of TRUE : 1
Value of FALSE : 0

C &
C

stdin

stdout

stderr

getchar() & putchar()

int getchar(void)

int putchar(int c)

#include <stdio.h>
int main( )
{
int c;
printf( "Enter a value :");
c = getchar( );
printf( "\nYou entered: ");
putchar( c );
return 0;
}


$./a.out
<b>Enter a value :</b> this is test
<b>You entered:</b> t

gets() & puts()

char *gets(char *s) stdin s EOF
int puts(const char *s) s stdout
#include <stdio.h>
int main( )
{
char str[100];
printf( "Enter a value :");
gets( str );
printf( "\nYou entered: ");
puts( str );
return 0;
}

$./a.out
<b>Enter a value :</b> this is test
<b>You entered:</b> This is test

scanf() printf()
int scanf(const char *format, ...) stdin format

int printf(const char *format, ...) stdout

format %s%d%c%f

#include <stdio.h>
int main( )
{

char str[100];
int i;
printf( "Enter a value :");
scanf("%s %d", str, &i);
printf( "\nYou entered: %s %d ", str, i);
return 0;
}

$./a.out
<b>Enter a value :</b> seven 7
<b>You entered:</b> seven 7

scanf() %s %d
"string integer" "string string" "integer integer"
scanf() "this is test"
scanf()

C
C C

C
OS

fopen( ) FILE
FILE
FILE *fopen( const char * filename, const char * mode );

filename mode

r+

w+

a+

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

fclose( )
int fclose( FILE *fp );

fclose( ) EOF
EOF
stdio.h
C

int fputc( int c, FILE *fp );

fputc() c fp
EOF null
int fputs( const char *s, FILE *fp );

fputs() s fp
EOF int fprintf(FILE *fp,const char *format, ...)

/tmp
#include <stdio.h>
main()

{
FILE *fp;
fp = fopen("/tmp/test.txt", "w+");
fprintf(fp, "This is testing for fprintf...\n");
fputs("This is testing for fputs...\n", fp);
fclose(fp);
}

/tmp test.txt

int fgetc( FILE * fp );

fgetc() fp
EOF
char *fgets( char *buf, int n, FILE *fp );

fgets() fp n - 1 buf
null
'\n' EOF
int fscanf(FILE *fp, const char *format, ...)

#include <stdio.h>
main()
{
FILE *fp;
char buff[255];
fp = fopen("/tmp/test.txt", "r");
fscanf(fp, "%s", buff);
printf("1 : %s\n", buff );
fgets(buff, 255, (FILE*)fp);
printf("2: %s\n", buff );
fgets(buff, 255, (FILE*)fp);
printf("3: %s\n", buff );
fclose(fp);
}


1 : This
2: is testing for fprintf...
3: This is testing for fputs...

fscanf() This fgets()

fgets()

I/O

size_t fread(void *ptr, size_t size_of_elements,

size_t number_of_elements, FILE *a_file);
size_t fwrite(const void *ptr, size_t size_of_elements,
size_t number_of_elements, FILE *a_file);

C
C C
C
C Preprocessor CPP
#

#define

#include

#undef

#ifdef

#ifndef

#if

#else

#if

#elif

#if

#endif

#if#else

#error

#pragma

#define MAX_ARRAY_LENGTH 20

CPP MAX_ARRAY_LENGTH 20 #define

#include <stdio.h>
#include "myheader.h"

CPP stdio.h CPP

myheader.h
#undef FILE_SIZE
#define FILE_SIZE 42

CPP FILE_SIZE 42
#ifndef MESSAGE
#define MESSAGE "You wish!"
#endif

CPP MESSAGE MESSAGE

#ifdef DEBUG
/* Your debugging statements here */
#endif

CPP DEBUG gcc DDEBUG DEBUG

ANSI C

__DATE__

"MMM DD YYYY"

__TIME__

"HH:MM:SS"

__FILE__

__LINE__

__STDC__

ANSI 1

#include <stdio.h>
main()
{
printf("File
printf("Date
printf("Time
printf("Line
printf("ANSI

:%s\n",
:%s\n",
:%s\n",
:%d\n",
:%d\n",

__FILE__
__DATE__
__TIME__
__LINE__
__STDC__

);
);
);
);
);

test.c
File
Date
Time
Line
ANSI

:test.c
:Jun 2 2012
:03:36:24
:8
:1

C
\
\

#define message_for(a, b) \
printf(#a " and " #b ": We love you!\n")

#
#

#include <stdio.h>

#define message_for(a, b) \
printf(#a " and " #b ": We love you!\n")
int main(void)
{
message_for(Carole, Debra);
return 0;
}

Carole and Debra: We love you!

##
##

#include <stdio.h>
#define tokenpaster(n) printf ("token" #n " = %d", token##n)
int main(void)
{
int token34 = 40;
tokenpaster(34);
return 0;
}

token34 = 40

printf ("token34 = %d", token34);

token##n token34 #
##
defined()
defined #define

defined()

#include <stdio.h>
#if !defined (MESSAGE)
#define MESSAGE "You wish!"
#endif
int main(void)
{
printf("Here is the message: %s\n", MESSAGE);
return 0;
}

Here is the message: You wish!

CPP
int square(int x) {
return x * x;
}

#define square(x) ((x) * (x))

#define

#include <stdio.h>
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main(void)
{
printf("Max between 20 and 10 is %d\n", MAX(10, 20));
return 0;
}

Max between 20 and 10 is 20

 .h C

C #include stdio.h

A simple practice in C C++

#include
#include <file>

file
-I
#include "file"

file
-I

#include C
#include header.h

char *test (void);

program.c
int x;
#include "header.h"
int main (void)
{
puts (test ());
}

int x;

char *test (void);

int main (void)
{
puts (test ());
}

#ifndef HEADER_FILE
#define HEADER_FILE
the entire header file file
#endif

#ifndef HEADER_FILE

#if SYSTEM_1
# include "system_1.h"
#elif SYSTEM_2
# include "system_2.h"
#elif SYSTEM_3
...
#endif

#include
#define SYSTEM_H "system_1.h"
...
#include SYSTEM_H

SYSTEM_H system_1.h #include SYSTEM_H

-D Makefile

 long
long int

(type_name) expression

#include <stdio.h>
main()
{
int sum = 17, count = 5;
double mean;
mean = (double) sum / count;
printf("Value of mean : %f\n", mean );
}

Value of mean : 3.400000

sum double
count double

int unsigned int int unsigned int

int
#include <stdio.h>
main()
{
int i = 17;
char c = 'c'; /* ascii 99 */
int sum;
sum = i + c;
printf("Value of sum : %d\n", sum );
}


Value of sum : 116

sum 116 'c'

ascii

&& ||
#include <stdio.h>
main()
{
int i = 17;
char c = 'c'; /* ascii 99 */
float sum;
sum = i + c;
printf("Value of sum : %f\n", sum );
}

Value of sum : 116.000000

c double
i c

C
C
C UNIX 1 NULL
errno <error.h>

C
errno 00

errnoperror() strerror()

C perror() strerror() errno

perror() errno
strerror() errno

stderr
#include <stdio.h>
#include <errno.h>
#include <string.h>
extern int errno ;
int main ()
{
FILE * pf;
int errnum;
pf = fopen ("unexist.txt", "rb");
if (pf == NULL)
{
errnum = errno;
fprintf(stderr, "Value of errno: %d\n", errno);
perror("Error printed by perror");
fprintf(stderr, "Error opening file: %s\n", strerror( errnum ));
}
else
{
fclose (pf);
}
return 0;
}

Value of errno: 2
Error printed by perror: No such file or directory
Error opening file: No such file or directory

#include <stdio.h>
#include <stdlib.h>
main()

{
int dividend = 20;
int divisor = 0;
int quotient;
if( divisor == 0){
fprintf(stderr, "Division by zero! Exiting...\n");
exit(-1);
}
quotient = dividend / divisor;
fprintf(stderr, "Value of quotient : %d\n", quotient );
exit(0);
}

Division by zero! Exiting...

EXIT_SUCCESS
EXIT_SUCCESS 0
EXIT_FAILURE -1

#include <stdio.h>
#include <stdlib.h>
main()
{
int dividend = 20;
int divisor = 5;
int quotient;
if( divisor == 0){
fprintf(stderr, "Division by zero! Exiting...\n");
exit(EXIT_FAILURE);
}
quotient = dividend / divisor;
fprintf(stderr, "Value of quotient : %d\n", quotient );
exit(EXIT_SUCCESS);
}

Value of quotient : 4

void recursion()
{
recursion(); /* */
}
int main()
{
recursion();
}

#include <stdio.h>
int factorial(unsigned int i)
{
if(i <= 1)
{
return 1;
}
return i * factorial(i - 1);
}
int main()
{
int i = 15;
printf("Factorial of %d is %d\n", i, factorial(i));
return 0;
}

Factorial of 15 is 2004310016


#include <stdio.h>
int fibonaci(int i)
{
if(i == 0)
{
return 0;
}
if(i == 1)
{
return 1;
}
return fibonaci(i-1) + fibonaci(i-2);
}
int
{

main()
int i;
for (i = 0; i < 10; i++)
{
printf("%d\t%n", fibonaci(i));
}
return 0;

13

21

34

C
C

int func(int, ... )

{
.
.
.
}
int main()
{
func(1, 2, 3);
func(1, 2, 3, 4);
}

 func() ... int

stdarg.h

int
va_list stdarg.h
int va_start va_list va_start stdarg.h

va_arg va_list
va_end va_list

#include <stdio.h>
#include <stdarg.h>
double average(int num,...)
{
va_list valist;
double sum = 0.0;
int i;
/* num valist */
va_start(valist, num);
/* valist */
for (i = 0; i < num; i++)
{
sum += va_arg(valist, int);
}
/* valist */
va_end(valist);
return sum/num;
}
int main()
{
printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2,3,4,5));
printf("Average of 5, 10, 15 = %f\n", average(3, 5,10,15));
}

average()

Average of 2, 3, 4, 5 = 3.500000
Average of 5, 10, 15 = 10.000000

C
C C
<stdlib.h>

void *calloc(int num, int size);

function allocates an array of num
size

void free(void *address);

address h

void *malloc(int num);

num

void *realloc(void *address, int newsize);

newsize

100
char name[100];

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char name[100];
char *description;
strcpy(name, "Zara Ali");
/* */
description = malloc( 200 * sizeof(char) );
if( description == NULL )
{
fprintf(stderr, "Error - unable to allocate required memory\n");
}
else

{
strcpy( description, "Zara ali a DPS student in class 10th");
}
printf("Name = %s\n", name );
printf("Description: %s\n", description );
}

Name = Zara Ali

Description: Zara ali a DPS student in class 10th

calloc() malloc calloc

calloc(200, sizeof(char));

free()
realloc() realloc()
free()
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
char name[100];
char *description;
strcpy(name, "Zara Ali");
/* */
description = malloc( 30 * sizeof(char) );
if( description == NULL )
{
fprintf(stderr, "Error - unable to allocate required memory\n");
}
else
{
strcpy( description, "Zara ali a DPS student.");
}
/* */

description = realloc( description, 100 * sizeof(char) );

if( description == NULL )
{
fprintf(stderr, "Error - unable to allocate required memory\n");
}
else
{
strcat( description, "She is in class 10th");
}
printf("Name = %s\n", name );
printf("Description: %s\n", description );
/* free() */
free(description);
}

Name = Zara Ali

Description: Zara ali a DPS student.She is in class 10th

strcat() description

C
C

main() argc argv[]

#include <stdio.h>
int main( int argc, char *argv[] )
{
if( argc == 2 )
{
printf("The argument supplied is %s\n", argv[1]);
}
else if( argc > 2 )
{
printf("Too many arguments supplied.\n");
}
else
{
printf("One argument expected.\n");

}
}

$./a.out testing
The argument supplied is testing

$./a.out testing1 testing2

Too many arguments supplied.

$./a.out
One argument expected

argv[0] argv[1] *argv[n]

argc 1argc
2

"" ''
""""

#include <stdio.h>
int main( int argc, char *argv[] )
{
printf("Program name %s\n", argv[0]);
if( argc == 2 )
{
printf("The argument supplied is %s\n", argv[1]);
}
else if( argc > 2 )
{
printf("Too many arguments supplied.\n");
}
else
{
printf("One argument expected.\n");
}
}

$./a.out "testing1 testing2"

Progranm name ./a.out
The argument supplied is testing1 testing2

C - <assert.h>

C assert.h assert

assert NDEBUG NDEBUG <assert.h>

<assert.h> NDEBUG assert
#define assert(ignore) ((void)0)

assert.h

&
void assert(int expression)
C

C - assert()

C void assert(int expression)

C

assert()
void assert(int expression);

expression -- C expression TRUEassert()

expression FALSEassert() stderr

assert()
#include <assert.h>
#include <stdio.h>
int main()
{
int a;
char str[50];
printf(" ");
scanf("%d\n", &a);
assert(a >= 10);
printf(" %d\n", a);
printf(" ");
scanf("%s\n", &str);
assert(str != NULL);
printf(" %s\n", str);
return(0);
}

11
11
w3cschool
w3cschool

C - <ctype.h>

C ctype.h
int EOF
c true c

 ctype.h

&

int isalnum(int c)

int isalpha(int c)

int iscntrl(int c)

int isdigit(int c)

int isgraph(int c)

int islower(int c)

int isprint(int c)

int ispunct(int c)

int isspace(int c)

10

int isupper(int c)

11

int isxdigit(int c)

"int"

&

int tolower(int c)

int toupper(int c)

&

{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }

{ 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f }

{ a b c d e f g h i j k l m n o p q r s t u v w x y z }

{A B C D E F G H I J K L M N O P Q R S T U V W X Y Z }

! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~

10

11

ASCII 000 037

177DEL

12

13

C - isalnum()

C void isalnum(int c)

isalnum()

int isalnum(int c);

c --

c 0

isalnum()
#include <stdio.h>
#include <ctype.h>
int main()
{
int var1
int var2
int var3
int var4

=
=
=
=

'd';
'2';
'\t';
' ';

if( isalnum(var1)
{
printf("var1 =
}
else
{
printf("var1 =
}
if( isalnum(var2)
{
printf("var2 =
}
else
{
printf("var2 =
}
if( isalnum(var3)
{
printf("var3 =
}
else
{
printf("var3 =
}
if( isalnum(var4)

)
|%c| \n", var1 );

|%c| \n", var1 );

)
|%c| \n", var2 );

|%c| \n", var2 );

)
|%c| \n", var3 );

|%c| \n", var3 );

)

{
printf("var4 = |%c| \n", var4 );
}
else
{
printf("var4 = |%c| \n", var4 );
}
return(0);
}

var1
var2
var3
var4

=
=
=
=

|d|
|2|
| |
| |

C - isalpha()

C void isalpha(int c)

isalpha()
int isalpha(int c);

c --

c 0

isalpha()
#include <stdio.h>
#include <ctype.h>
int main()
{

int
int
int
int

var1
var2
var3
var4

=
=
=
=

'd';
'2';
'\t';
' ';

if( isalpha(var1)
{
printf("var1 =
}
else
{
printf("var1 =
}
if( isalpha(var2)
{
printf("var2 =
}
else
{
printf("var2 =
}
if( isalpha(var3)
{
printf("var3 =
}
else
{
printf("var3 =
}
if( isalpha(var4)
{
printf("var4 =
}
else
{
printf("var4 =
}

)
|%c| \n", var1 );

|%c| \n", var1 );

)
|%c| \n", var2 );

|%c| \n", var2 );

)
|%c| \n", var3 );

|%c| \n", var3 );

)
|%c| \n", var4 );

|%c| \n", var4 );

return(0);
}

var1
var2
var3
var4

=
=
=
=

|d|
|2|
| |
| |

C - iscntrl()


C void iscntrl(int c)
ASCII ASCII 0x00 (NUL) 0x1f (US) 0x7f
(DEL)0x7f

iscntrl()
int iscntrl(int c);

c --

c 0

iscntrl()
#include <stdio.h>
#include <ctype.h>
int main ()
{
int i = 0, j = 0;
char str1[] = "all \a about \t programming";
char str2[] = "w3cschool \n tutorials";
/* \a */
while( !iscntrl(str1[i]) )
{
putchar(str1[i]);
i++;
}
/* \n */
while( !iscntrl(str2[j]) )
{
putchar(str2[j]);
j++;
}
return(0);

all w3cschool

C - isdigit()

C void isdigit(int c)
0 1 2 3 4 5 6 7 8 9

isdigit()
int isdigit(int c);

c --

c 0

isdigit()
#include <stdio.h>
#include <ctype.h>
int main()
{
int var1 = 'h';
int var2 = '2';
if( isdigit(var1) )
{
printf("var1 = |%c| \n", var1 );
}
else
{
printf("var1 = |%c| \n", var1 );

}
if( isdigit(var2) )
{
printf("var2 = |%c| \n", var2 );
}
else
{
printf("var2 = |%c| \n", var2 );
}
return(0);
}

var1 = |h|
var2 = |2|

C - isgraph()

C void isgraph(int c)
' '

isgraph()
int isgraph(int c);

c --

c 0

isgraph()
#include <stdio.h>
#include <ctype.h>

int main()
{
int var1 = '3';
int var2 = 'm';
int var3 = ' ';
if( isgraph(var1) )
{
printf("var1 = |%c| \n", var1 );
}
else
{
printf("var1 = |%c| \n", var1 );
}
if( isgraph(var2) )
{
printf("var2 = |%c| \n", var2 );
}
else
{
printf("var2 = |%c| \n", var2 );
}
if( isgraph(var3) )
{
printf("var3 = |%c| \n", var3 );
}
else
{
printf("var3 = |%c| \n", var3 );
}
return(0);
}

var1 = |3|
var2 = |m|
var3 = | |

C - islower()

C int islower(int c)

islower()

int islower(int c);

c --

c true 0false

islower()
#include <stdio.h>
#include <ctype.h>
int main()
{
int var1 = 'Q';
int var2 = 'q';
int var3 = '3';
if( islower(var1) )
{
printf("var1 = |%c| \n", var1 );
}
else
{
printf("var1 = |%c| \n", var1 );
}
if( islower(var2) )
{
printf("var2 = |%c| \n", var2 );
}
else
{
printf("var2 = |%c| \n", var2 );
}
if( islower(var3) )
{
printf("var3 = |%c| \n", var3 );
}
else
{
printf("var3 = |%c| \n", var3 );
}
return(0);

var1 = |Q|
var2 = |q|
var3 = |3|

C - isprint()

C int isprint(int c)

isprint()
int isprint(int c);

c --

c true 0false

isprint()
#include <stdio.h>
#include <ctype.h>
int main()
{
int var1
int var2
int var3
int var4

=
=
=
=

'k';
'8';
'\t';
' ';

if( isprint(var1) )
{
printf("var1 = |%c| \n", var1 );
}
else

{
printf("var1 = |%c| \n", var1 );
}
if( isprint(var2)
{
printf("var2 =
}
else
{
printf("var2 =
}
if( isprint(var3)
{
printf("var3 =
}
else
{
printf("var3 =
}
if( isprint(var4)
{
printf("var4 =
}
else
{
printf("var4 =
}

)
|%c| \n", var2 );

|%c| \n", var2 );

)
|%c| \n", var3 );

|%c| \n", var3 );

)
|%c| \n", var4 );

|%c| \n", var4 );

return(0);
}

var1
var2
var3
var4

=
=
=
=

|k|
|8|
|
|
| |

C - ispunct()

C int ispunct(int c)
isalnum isgraph

ispunct()

int ispunct(int c);

c --

c true 0false

ispunct()
#include <stdio.h>
#include <ctype.h>
int main()
{
int var1
int var2
int var3
int var4

=
=
=
=

't';
'1';
'/';
' ';

if( ispunct(var1) )
{
printf("var1 = |%c|
}
else
{
printf("var1 = |%c|
}
if( ispunct(var2) )
{
printf("var2 = |%c|
}
else
{
printf("var2 = |%c|
}
if( ispunct(var3) )
{
printf("var3 = |%c|
}
else
{
printf("var3 = |%c|
}
if( ispunct(var4) )
{

\n", var1 );

\n", var1 );

\n", var2 );

\n", var2 );

\n", var3 );

\n", var3 );

printf("var4 = |%c| \n", var4 );

}
else
{
printf("var4 = |%c| \n", var4 );
}
return(0);
}

var1
var2
var3
var4

=
=
=
=

|t|
|1|
|/|
| |

C - isspace()

C int isspace(int c)

' '
'\t'
'\n'
'\v'
'\f'
'\r'

(0x20)
(0x09)
(0x0a)
(0x0b)
(0x0c)
(0x0d)

space (SPC)
horizontal tab (TAB)
newline (LF)
vertical tab (VT)
feed (FF)
carriage return (CR)

isspace()
int isspace(int c);

c --

c true 0false

 isspace()
#include <stdio.h>
#include <ctype.h>
int main()
{
int var1 = 't';
int var2 = '1';
int var3 = ' ';
if( isspace(var1) )
{
printf("var1 = |%c|
}
else
{
printf("var1 = |%c|
}
if( isspace(var2) )
{
printf("var2 = |%c|
}
else
{
printf("var2 = |%c|
}
if( isspace(var3) )
{
printf("var3 = |%c|
}
else
{
printf("var3 = |%c|
}

\n", var1 );

\n", var1 );

\n", var2 );

\n", var2 );

\n", var3 );

\n", var3 );

return(0);
}

var1 = |t|
var2 = |1|
var3 = | |

C - isupper()

C int isupper(int c)

isupper()
int isupper(int c);

c --

c true 0false

isupper()
#include <stdio.h>
#include <ctype.h>
int main()
{
int var1 = 'M';
int var2 = 'm';
int var3 = '3';
if( isupper(var1)
{
printf("var1 =
}
else
{
printf("var1 =
}
if( isupper(var2)
{
printf("var2 =
}
else
{
printf("var2 =
}
if( isupper(var3)
{
printf("var3 =
}

)
|%c| \n", var1 );

|%c| \n", var1 );

)
|%c| \n", var2 );

|%c| \n", var2 );

)
|%c| \n", var3 );

else
{
printf("var3 = |%c| \n", var3 );
}
return(0);
}

var1 = |M|
var2 = |m|
var3 = |3|

C - isxdigit()

C int isxdigit(int c)

isxdigit()
int isxdigit(int c);

c --

c true 0false

isxdigit()
#include <stdio.h>
#include <ctype.h>
int main()
{
char var1[] = "tuts";
char var2[] = "0xE";
if( isxdigit(var1[0]) )

{
printf("var1 = |%s| \n", var1 );
}
else
{
printf("var1 = |%s| \n", var1 );
}
if( isxdigit(var2[0] ))
{
printf("var2 = |%s| \n", var2 );
}
else
{
printf("var2 = |%s| \n", var2 );
}
return(0);
}

var1 = |tuts|
var2 = |0xE|

C - <errno.h>

C errno.h errno
int

errno C

errno.h int

errno.h

&
extern int errno

EDOM Domain Error

errno
EDOM

ERANGE Range Error

errno ERANGE

C - errno

C extern int errno

errno
extern int errno

NA

NA

errno
#include <stdio.h>
#include <errno.h>
#include <string.h>
extern int errno ;
int main ()
{
FILE *fp;
fp = fopen("file.txt", "r");
if( fp == NULL )
{
fprintf(stderr, "Value of errno: %d\n", errno);

fprintf(stderr, "Error opening file: %s\n", strerror(errno));

}
else
{
fclose(fp);
}
return(0);
}

file.txt
Value of errno: 2
Error opening file: No such file or directory

C - EDOM

C EDOM errno
EDOM

EDOM
#define EDOM some_value

NA

NA

EDOM
#include <stdio.h>
#include <errno.h>
#include <math.h>
int main()
{
double val;

errno = 0;
val = sqrt(-10);
if(errno == EDOM)
{
printf("Invalid value \n");
}
else
{
printf("Valid value\n");
}
errno = 0;
val = sqrt(10);
if(errno == EDOM)
{
printf("Invalid value\n");
}
else
{
printf("Valid value\n");
}
return(0);
}

Invalid value
Valid value

C - ERANGE

C ERANGE errno
ERANGE

ERANGE
#define ERANGE some_value

NA


NA

ERANGE
#include <stdio.h>
#include <errno.h>
#include <math.h>
int main()
{
double x;
double value;
x = 1.000000;
value = log(x);
if( errno == ERANGE )
{
printf("Log(%f) is out of range\n", x);
}
else
{
printf("Log(%f) = %f\n", x, value);
}
x = 0.000000;
value = log(x);
if( errno == ERANGE )
{
printf("Log(%f) is out of range\n" x);
}
else
{
printf("Log(%f) = %f\n", x, value);
}
return 0;
}

Log(1.000000) = 1.609438
Log(0.000000) is out of range

C - <float.h>


C float.h ANSI C

( +/- )

2 10 16 ...

emin emax

4
floating-point = ( S ) p x b^e

floating-point = (+/-) precision x base^exponent

#define
FLT floatDBL doubleLDBL long double

-1 -
0 -

FLT_ROUNDS

1 -
2 -
3 -

FLT_RADIX 2

2
10 16

FLT_MANT_DIG
DBL_MANT_DIG
LDBL_MANT_DIG

FLT_RADIX

FLT_DIG 6
DBL_DIG 10

10

LDBL_DIG 10

FLT_MIN_EXP
DBL_MIN_EXP

FLT_RADIX

LDBL_MIN_EXP

FLT_MIN_10_EXP
-37
DBL_MIN_10_EXP
-37

10

LDBL_MIN_10_EXP
-37

FLT_MAX_EXP
DBL_MAX_EXP

FLT_RADIX

LDBL_MAX_EXP

FLT_MAX_10_EXP
+37
DBL_MAX_10_EXP
+37

10

LDBL_MAX_10_EXP
+37

FLT_MAX 1E+37
DBL_MAX 1E+37

LDBL_MAX 1E+37

FLT_EPSILON 1E-5
DBL_EPSILON 1E-9

LDBL_EPSILON 1E-9

FLT_MIN 1E-37
DBL_MIN 1E-37

LDBL_MIN 1E-37

float.h
#include <stdio.h>
#include <float.h>
int main()
{
printf("The maximum value of float = %.10e\n", FLT_MAX);
printf("The minimum value of float = %.10e\n", FLT_MIN);
printf("The number of digits in the number = %.10e\n", FLT_MANT_DIG);
}

The maximum value of float = 3.4028234664e+38

The minimum value of float = 1.1754943508e-38
The number of digits in the number = 7.2996655210e-312

C - <limits.h>

limits.h
charint long
255

#define

CHAR_BIT

SCHAR_MIN

-128

SCHAR_MAX

127

UCHAR_MAX

255

char char
SCHAR_MIN
0

CHAR_MAX

127

char char
SCHAR_MAX
UCHAR_MAX

MB_LEN_MAX

SHRT_MIN

-32768

SHRT_MAX

+32767

USHRT_MAX

65535

INT_MIN

-32768

INT_MAX

+32767

UINT_MAX

65535

LONG_MIN

-2147483648

LONG_MAX

+2147483647

ULONG_MAX

4294967295

CHAR_MIN

limit.h
#include <stdio.h>
#include <limits.h>
int main()
{
printf("The number of bits in a byte %d\n", CHAR_BIT);
printf("The minimum value of SIGNED CHAR = %d\n", SCHAR_MIN);
printf("The maximum value of SIGNED CHAR = %d\n", SCHAR_MAX);
printf("The maximum value of UNSIGNED CHAR = %d\n", UCHAR_MAX);
printf("The minimum value of SHORT INT = %d\n", SHRT_MIN);
printf("The maximum value of SHORT INT = %d\n", SHRT_MAX);

printf("The minimum value of INT = %d\n", INT_MIN);

printf("The maximum value of INT = %d\n", INT_MAX);
printf("The minimum value of CHAR = %d\n", CHAR_MIN);
printf("The maximum value of CHAR = %d\n", CHAR_MAX);
printf("The minimum value of LONG = %ld\n", LONG_MIN);
printf("The maximum value of LONG = %ld\n", LONG_MAX);
return(0);
}

The
The
The
The
The
The
The
The
The
The
The
The

number of bits in a byte 8

minimum value of SIGNED CHAR = -128
maximum value of SIGNED CHAR = 127
maximum value of UNSIGNED CHAR = 255
minimum value of SHORT INT = -32768
maximum value of SHORT INT = 32767
minimum value of INT = -32768
maximum value of INT = 32767
minimum value of CHAR = -128
maximum value of CHAR = 127
minimum value of LONG = -2147483648
maximum value of LONG = 2147483647

C - <locale.h>

locale.h
struct lconv

locale.h

&

LC_ALL

LC_COLLATE
strcoll strxfrm

LC_CTYPE

LC_MONETARY
localeconv

LC_NUMERIC
localeconv

LC_TIME
strftime

locale.h

&

char *setlocale(int category, const char *locale)

struct lconv *localeconv(void)

typedef
char
char
char
char
char
char
char
char
char
char
char
char
char
char
char
char
char
char
} lconv

struct {
*decimal_point;
*thousands_sep;
*grouping;
*int_curr_symbol;
*currency_symbol;
*mon_decimal_point;
*mon_thousands_sep;
*mon_grouping;
*positive_sign;
*negative_sign;
int_frac_digits;
frac_digits;
p_cs_precedes;
p_sep_by_space;
n_cs_precedes;
n_sep_by_space;
p_sign_posn;
n_sign_posn;

&

decimal_point

thousands_sep

grouping

int_curr_symbol
ISO 4217:1987

currency_symbol

mon_decimal_point

mon_thousands_sep

mon_grouping

positive_sign

10

negative_sign

11

int_frac_digits

12

frac_digits

13

p_cs_precedes
1 currency_symbol 0
currency_symbol

14

p_sep_by_space
1 currency_symbol
0 currency_symbol

15

n_cs_precedes
1 currency_symbol 0
currency_symbol

16

n_sep_by_space
1 currency_symbol
0 currency_symbol

17

18

p_sign_posn

n_sign_posn

p_sign_posn n_sign_posn:

currency_symbol

currency_symbol

currency_symbol

currency_symbol

currency_symbol

C - setlocale()

C char *setlocale(int category, const char *locale)

setlocale()
char *setlocale(int category, const char *locale)

category --
LC_ALL
LC_COLLATE strcoll()
LC_CTYPE strtoupper()
LC_MONETARY localeconv()
LC_NUMERIC localeconv()
LC_TIME strftime()
LC_MESSAGES

locale -- locale NULL ""

setlocale()
NULL

setlocale()
#include <locale.h>
#include <stdio.h>
#include <time.h>
int main ()
{
time_t currtime;
struct tm *timer;
char buffer[80];
time( &currtime );
timer = localtime( &currtime );
printf("Locale is: %s\n", setlocale(LC_ALL, "en_GB"));
strftime(buffer,80,"%c", timer );
printf("Date is: %s\n", buffer);

printf("Locale is: %s\n", setlocale(LC_ALL, "de_DE"));

strftime(buffer,80,"%c", timer );
printf("Date is: %s\n", buffer);
return(0);
}

Locale is: en_GB

Date is: Thu 23 Aug 2012 06:39:32 MST
Locale is: de_DE
Date is: Do 23 Aug 2012 06:39:32 MST

C - localeconv()

C struct lconv *localeconv(void) lconv

localeconv()
struct lconv *localeconv(void)

NA

struct lconv
typedef
char
char
char
char
char
char
char
char
char
char
char
char
char
char
char
char
char
char
} lconv

struct {
*decimal_point;
*thousands_sep;
*grouping;
*int_curr_symbol;
*currency_symbol;
*mon_decimal_point;
*mon_thousands_sep;
*mon_grouping;
*positive_sign;
*negative_sign;
int_frac_digits;
frac_digits;
p_cs_precedes;
p_sep_by_space;
n_cs_precedes;
n_sep_by_space;
p_sign_posn;
n_sign_posn;

localeconv()
#include <locale.h>
#include <stdio.h>
int main ()
{
struct lconv * lc;

setlocale(LC_MONETARY, "it_IT");
lc = localeconv();
printf("Local Currency Symbol: %s\n",lc->currency_symbol);
printf("International Currency Symbol: %s\n",lc->int_curr_symbol);
setlocale(LC_MONETARY, "en_US");
lc = localeconv();
printf("Local Currency Symbol: %s\n",lc->currency_symbol);
printf("International Currency Symbol: %s\n",lc->int_curr_symbol);
setlocale(LC_MONETARY, "en_GB");
lc = localeconv();
printf ("Local Currency Symbol: %s\n",lc->currency_symbol);
printf ("International Currency Symbol: %s\n",lc->int_curr_symbol);
printf("Decimal Point = %s\n", lc->decimal_point);
return 0;
}

Local Currency Symbol:

International Currency
Local Currency Symbol:
International Currency
Local Currency Symbol:
International Currency
Decimal Point = .

EUR
Symbol: EUR
$
Symbol: USD

Symbol: GBP

C - <math.h>

math.h double
double

&
HUGE_VAL

errno ERANGE

HUGE_VAL - HUGE_VAL
error
ERANGE ERANGE

math.h

&

double acos(double x)
x

double asin(double x)
x

double atan(double x)
x

double atan2(double y, double x)

y/x y x

double cos(double x)
x

double cosh(double x)
x

double sin(double x)
x

double sinh(double x)
x

double tanh(double x)
x

10

double exp(double x)
e x

11

double frexp(double x, int *exponent)

x exponent
x = mantissa * 2 ^ exponent

12

double ldexp(double x, int exponent)

x 2 exponent

13

double log(double x)
x e

14

double log10(double x)

 x 10
15

double modf(double x, double *integer)

integer

16

double pow(double x, double y)

x y

17

double sqrt(double x)
x

18

double ceil(double x)
x

19

double fabs(double x)
x

20

double floor(double x)
x

21

double fmod(double x, double y)

x y

C - acos()

C double acos(double x) x

acos()
double acos(double x)

x -- [-1,+1]

x [0, pi]

acos()
#include <stdio.h>
#include <math.h>

#define PI 3.14159265
int main ()
{
double x, ret, val;
x = 0.9;
val = 180.0 / PI;
ret = acos(x) * val;
printf("%lf %lf ", x, ret);
return(0);
}

0.900000 25.855040

C - asin()

C double asin(double x) x

asin()
double asin(double x)

x -- [-1,+1]

x [-pi/2,+pi/2]

asin()
#include <stdio.h>
#include <math.h>

#define PI 3.14159265
int main ()
{
double x, ret, val;
x = 0.9;
val = 180.0 / PI;
ret = asin(x) * val;
printf("%lf %lf ", x, ret);
return(0);
}

0.900000 64.190609

C - atan()

C double atan(double x) x

atan()
double atan(double x)

x --

x [-pi/2,+pi/2]

atan()
#include <stdio.h>
#include <math.h>
#define PI 3.14159265

int main ()
{
double x, ret, val;
x = 1.0;
val = 180.0 / PI;
ret = atan (x) * val;
printf("%lf %lf ", x, ret);
return(0);
}

1.000000 45.000000

C - atan2()

C double atan2(doubly y, double x) y/x y x

atan2()
double atan2(doubly y, double x)

x -- x
y -- y

y/x [-pi,+pi]

atan2()
#include <stdio.h>
#include <math.h>
#define PI 3.14159265

int main ()
{
double x, y, ret, val;
x = -7.0;
y = 7.0;
val = 180.0 / PI;
ret = atan2 (y,x) * val;
printf("x = %lf, y = %lf ", x, y);
printf(" %lf \n", ret);
return(0);
}

x = -7.000000, y = 7.000000 135.000000

C - cos()

C double cos(double x) x

cos()
double cos(double x)

x --

cos()
#include <stdio.h>
#include <math.h>

#define PI 3.14159265
int main ()
{
double x, ret, val;
x = 60.0;
val = PI / 180.0;
ret = cos( x*val );
printf("%lf %lf \n", x, ret);
x = 90.0;
val = PI / 180.0;
ret = cos( x*val );
printf("%lf %lf \n", x, ret);
return(0);
}

60.000000 0.500000
90.000000 0.000000

C - cosh()

C double cosh(double x) x

cosh()
double cosh(double x)

x --

cosh()

#include <stdio.h>
#include <math.h>
int main ()
{
double x;
x = 0.5;
printf("%lf %lf\n", x, cosh(x));
x = 1.0;
printf("%lf %lf\n", x, cosh(x));
x = 1.5;
printf("%lf %lf\n", x, cosh(x));
return(0);
}

0.500000 1.127626
1.000000 1.543081
1.500000 2.352410

C - sin()

C double sin(double x) x

sin()
double sin(double x)

x --

 sin()
#include <stdio.h>
#include <math.h>
#define PI 3.14159265
int main ()
{
double x, ret, val;
x = 45.0;
val = PI / 180;
ret = sin(x*val);
printf("%lf %lf ", x, ret);
return(0);
}

45.000000 0.707107

C - sinh()

C double sinh(double x) x

sinh()
double sinh(double x)

x --

sinh()

#include <stdio.h>
#include <math.h>
int main ()
{
double x, ret;
x = 0.5;
ret = sinh(x);
printf("%lf %lf ", x, ret);
return(0);
}

0.500000 0.521095

C - tanh()

C double tanh(double x) x

tanh()
double tanh(double x)

x --

tanh()
#include <stdio.h>
#include <math.h>
int main ()
{

double x, ret;
x = 0.5;
ret = tanh(x);
printf("%lf %lf ", x, ret);
return(0);
}

0.500000 0.462117

C - exp()

C double exp(double x) e x

exp()
double exp(double x)

x --

e x

exp()
#include <stdio.h>
#include <math.h>
int main ()
{
double x = 0;
printf("e %lf %lf\n", x, exp(x));
printf("e %lf %lf\n", x+1, exp(x+1));
printf("e %lf %lf\n", x+2, exp(x+2));

return(0);
}

e 0.000000 1.000000
e 1.000000 2.718282
e 2.000000 7.389056

C - frexp()

C double frexp(double x, int *exponent) x

exponent x = mantissa * 2 ^ exponent

frexp()
double frexp(double x, int *exponent)

x --
exponent --

x x
1/2 1 x exp

frexp()
#include <stdio.h>
#include <math.h>
int main ()
{
double x = 1024, fraction;
int e;
fraction = frexp(x, &e);

printf("x = %.2lf = %.2lf * 2^%d\n", x, fraction, e);

return(0);
}

x = 1024.00 = 0.50 * 2^11

C - ldexp()

C double ldexp(double x, int exponent) x 2 exponent

ldexp()
double ldexp(double x, int exponent)

x --
exponent --

x * 2 exp

ldexp()
#include <stdio.h>
#include <math.h>
int main ()
{
double x, ret;
int n;
x = 0.65;
n = 3;
ret = ldexp(x ,n);
printf("%f * 2^%d = %f\n", x, n, ret);

return(0);
}

0.650000 * 2^3 = 5.200000

C - log()

C double log(double x) x e

log()
double log(double x)

x --

log()
#include <stdio.h>
#include <math.h>
int main ()
{
double x, ret;
x = 2.7;
/* log(2.7) */
ret = log(x);
printf("log(%lf) = %lf", x, ret);
return(0);
}


log(2.700000) = 0.993252

C - log10()

C double log10(double x) x 10

log10()
double log10(double x)

x --

x x 0

log10()
#include <stdio.h>
#include <math.h>
int main ()
{
double x, ret;
x = 10000;
/* log10(10000) */
ret = log10(x);
printf("log10(%lf) = %lf\n", x, ret);
return(0);
}

log10(10000.000000) = 4.000000

C - modf()

C double modf(double x, double *integer)

integer

modf()
double modf(double x, double *integer)

x --
integer --

x x

modf()
#include<stdio.h>
#include<math.h>
int main ()
{
double x, fractpart, intpart;
x = 8.123456;
fractpart = modf(x, &intpart);
printf(" = %lf\n", intpart);
printf(" = %lf \n", fractpart);
return(0);
}

= 8.000000
= 0.123456

C - pow()

C double pow(double x, double y) x y xy

pow()
double pow(double x, double y)

x --
y --

x y

pow()
#include <stdio.h>
#include <math.h>
int main ()
{
printf(" 8.0 ^ 3 = %lf\n", pow(8.0, 3));
printf(" 3.05 ^ 1.98 = %lf", pow(3.05, 1.98));
return(0);
}

8.0 ^ 3 = 512.000000
3.05 ^ 1.98 = 9.097324

C - sqrt()

C double sqrt(double x) x

sqrt()
double sqrt(double x)

x --

sqrt()
#include <stdio.h>
#include <math.h>
int main ()
{
printf("%lf %lf\n", 4.0, sqrt(4.0) );
printf("%lf %lf\n", 5.0, sqrt(5.0) );
return(0);
}

4.000000 2.000000
5.000000 2.236068

C - ceil()

C double ceil(double x) x

ceil()

double ceil(double x)

x --

ceil()
#include <stdio.h>
#include <math.h>
int main ()
{
float val1, val2, val3, val4;
val1
val2
val3
val4

=
=
=
=

printf
printf
printf
printf

1.6;
1.2;
2.8;
2.3;
("value1
("value2
("value3
("value4

=
=
=
=

%.1lf\n",
%.1lf\n",
%.1lf\n",
%.1lf\n",

ceil(val1));
ceil(val2));
ceil(val3));
ceil(val4));

return(0);
}

value1
value2
value3
value4

=
=
=
=

2.0
2.0
3.0
3.0

C - fabs()

C double fabs(double x) x


fabs()
double fabs(double x)

x --

fabs()
#include <stdio.h>
#include <math.h>
int main ()
{
int a, b;
a = 1234;
b = -344;
printf("%d %lf\n", a, fabs(a));
printf("%d %lf\n", b, fabs(b));
return(0);
}

1234 1234.000000
-344 344.000000

C - floor()

C double floor(double x) x

floor()

double floor(double x)

x --

floor()
#include <stdio.h>
#include <math.h>
int main ()
{
float val1, val2, val3, val4;
val1
val2
val3
val4

=
=
=
=

1.6;
1.2;
2.8;
2.3;

printf("Value1
printf("Value2
printf("Value3
printf("Value4

=
=
=
=

%.1lf\n",
%.1lf\n",
%.1lf\n",
%.1lf\n",

floor(val1));
floor(val2));
floor(val3));
floor(val4));

return(0);
}

Value1
Value2
Value3
Value4

=
=
=
=

1.0
1.0
2.0
2.0

C - fmod()

C double fmod(double x, double y) x y


fmod()
double fmod(double x, double y)

x --
y --

x/y

fmod()
#include <stdio.h>
#include <math.h>
int main ()
{
float a, b;
int c;
a = 9.2;
b = 3.7;
c = 2;
printf("%f / %d %lf\n", a, c, fmod(a,c));
printf("%f / %f %lf\n", a, b, fmod(a,b));
return(0);
}

9.200000 / 2 1.200000
9.200000 / 3.700000 1.800000

C - <setjmp.h>

setjmp.h setjmp() longjmp() jmp_buf


setjmp.h

&
jmp_buf
setjmp() longjmp()

&
int setjmp(jmp_buf environment)
environment longjmp()

longjmp()

setjmp.h

&

void longjmp(jmp_buf environment, int value)

setjmp() jmp_buf
setjmp()

C - setjmp()

C int setjmp(jmp_buf environment) environment

longjmp() longjmp()
longjmp

setjmp()
int setjmp(jmp_buf environment)


environment -- jmp_buf

longjmp
longjmp

setjmp()
#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
int main()
{
int val;
jmp_buf env_buffer;
/* longjmp */
val = setjmp( env_buffer );
if( val != 0 )
{
printf(" longjmp() = %s\n", val);
exit(0);
}
printf("\n");
jmpfunction( env_buffer );
return(0);
}
void jmpfunction(jmp_buf env_buf)
{
longjmp(env_buf, "w3cschool.cc");
}

longjmp() = w3cschool.cc

C - longjmp()


C void longjmp(jmp_buf environment, int value) setjmp()
jmp_buf setjmp()

longjmp()
void longjmp(jmp_buf environment, int value)

environment -- jmp_buf setjmp

value -- setjmp

longjmp()
#include <stdio.h>
#include <stdlib.h>
#include <setjmp.h>
int main()
{
int val;
jmp_buf env_buffer;
/* longjmp */
val = setjmp( env_buffer );
if( val != 0 )
{
printf(" longjmp() = %s\n", val);
exit(0);
}
printf("\n");
jmpfunction( env_buffer );
return(0);
}
void jmpfunction(jmp_buf env_buf)
{
longjmp(env_buf, "w3cschool.cc");

longjmp() = w3cschool.cc

C - <signal.h>

signal.h sig_atomic_t

signal.h

&
sig_atomic_t
int

signal.h SIG_ signal

&

SIG_DFL

SIG_ERR

SIG_IGN

SIG

&

SIGABRT

SIGFPE
0

SIGILL

SIGINT
ctrl-C

SIGSEGV

SIGTERM

signal.h

&

void (*signal(int sig, void (*func)(int)))(int)

int raise(int sig)

sigsig SIG

C - signal()

C void (*signal(int sig, void (*func)(int)))(int) sig

signal()
void (*signal(int sig, void (*func)(int)))(int)

sig --

SIGABRT

(Signal Abort)

SIGFPE

(Signal Floating-Point Exception) 0

SIGILL

(Signal Illegal Instruction)

SIGINT

(Signal Interrupt) ctrl-C

SIGSEGV

(Signal Segmentation Violation)

SIGTERM

(Signal Terminate)

func --

SIG_DFL

SIG_IGN

SIG_ERR

signal()
#include
#include
#include
#include

<stdio.h>
<unistd.h>
<stdlib.h>
<signal.h>

void sighandler(int);
int main()
{
signal(SIGINT, sighandler);
while(1)
{
printf("...\n");
sleep(1);
}
return(0);
}
void sighandler(int signum)

{
printf(" %d...\n", signum);
exit(1);
}

CTRL + C

...
...
...
...
...
2...

C - raise()

C int raise(int sig) sigsig SIG

raise()
int raise(int sig)

sig --

SIGABRT

(Signal Abort)

SIGFPE

(Signal Floating-Point Exception) 0

SIGILL

(Signal Illegal Instruction)

SIGINT

(Signal Interrupt) ctrl-C

SIGSEGV

(Signal Segmentation Violation)

SIGTERM

(Signal Terminate)

raise()
#include <signal.h>
#include <stdio.h>
void signal_catchfunc(int);
int main()
{
int ret;
ret = signal(SIGINT, signal_catchfunc);
if( ret == SIG_ERR)
{
printf("\n");
exit(0);
}
printf("\n");
ret = raise(SIGINT);
if( ret !=0 )
{
printf(" SIGINT \n");
exit(0);
}
printf("...\n");
return(0);
}
void signal_catchfunc(int signal)
{
printf("!! !!\n");
}

!! !!
...

C - <stdarg.h>


stdarg.h va_list

(,...)

stdarg.h

&
va_list
va_start()va_arg() va_end()

stdarg.h

&

void va_start(va_list ap, last_arg)

ap va_arg va_end last_arg

type va_arg(va_list ap, type)

type

void va_end(va_list ap)

va_start
va_end

C - va_start()

C void va_start(va_list ap, last_arg) ap va_arg va_end

last_arg
va_arg va_end

va_start()

void va_start(va_list ap, last_arg);

ap -- va_list va_arg
last_arg --

NA

va_start()
#include<stdarg.h>
#include<stdio.h>
int sum(int, ...);
int main(void)
{
printf("1020 30 = %d\n", sum(3, 10, 20, 30) );
printf("42025 30 = %d\n", sum(4, 4, 20, 25, 30) );
return 0;
}
int sum(int num_args, ...)
{
int val = 0;
va_list ap;
int i;
va_start(ap, num_args);
for(i = 0; i < num_args; i++)
{
val += va_arg(ap, int);
}
va_end(ap);
return val;
}

1020 30 = 60
42025 30 = 79

C - va_arg()

C type va_arg(va_list ap, type) type

va_arg()
type va_arg(va_list ap, type)

ap -- va_list
va_arg va_start
type --

type

va_arg()
#include <stdarg.h>
#include <stdio.h>
int sum(int, ...);
int main()
{
printf("15 56 = %d\n",
return 0;
}
int sum(int num_args, ...)
{
int val = 0;
va_list ap;
int i;
va_start(ap, num_args);
for(i = 0; i < num_args; i++)
{
val += va_arg(ap, int);

sum(2, 15, 56) );

}
va_end(ap);
return val;
}

15 56 = 71

C - va_end()

C void va_end(va_list ap) va_start

va_end

va_end()
void va_end(va_list ap)

ap -- va_start va_list

va_end()
#include <stdarg.h>
#include <stdio.h>
int mul(int, ...);
int main()
{
printf("15 * 12 = %d\n",
return 0;
}

mul(2, 15, 12) );

int mul(int num_args, ...)

{
int val = 1;
va_list ap;
int i;
va_start(ap, num_args);
for(i = 0; i < num_args; i++)
{
val *= va_arg(ap, int);
}
va_end(ap);
return val;
}

15 * 12 =

180

C - <stddef.h>

stddef .h

stddef.h

&

ptrdiff_t

size_t
sizeof

wchar_t

stddef.h

&

NULL

offsetof(type, member-designator)
size_t
member-designator type

C - NULL

C NULL ((void*)0), 0 0L

NULL
#define NULL ((char *)0)

#define NULL 0L

#define NULL 0

NA

NA

NULL
#include <stddef.h>
#include <stdio.h>
int main ()
{
FILE *fp;
fp = fopen("file.txt", "r");

if( fp != NULL )
{
printf(" file.txt\n");
fclose(fp);
}
fp = fopen("nofile.txt", "r");
if( fp == NULL )
{
printf(" nofile.txt\n");
}
return(0);
}

file.txt nofile.txt

file.txt
nofile.txt

C - offsetof()

C offsetof(type, member-designator) size_t

member-designator type

offsetof()
offsetof(type, member-designator)

type -- class member-designator

member-designator -- class

size_t type

offsetof()

#include <stddef.h>
#include <stdio.h>
struct address {
char name[50];
char street[50];
int phone;
};
int main()
{
printf("address name = %d \n",
offsetof(struct address, name));
printf("address street = %d \n",
offsetof(struct address, street));
printf("address phone = %d \n",
offsetof(struct address, phone));
return(0);
}

address name = 0
address street = 50
address phone = 100

C - <stdio.h>

stdio .h

stdio.h

&

size_t
sizeof

FILE

fpos_t

stdio.h

&

NULL

_IOFBF_IOLBF _IONBF
setvbuf

BUFSIZ
setbuf

EOFM

FOPEN_MAX

FILENAME_MAX

L_tmpnam
tmpnam

SEEK_CURSEEK_END SEEK_SET
These macros are used in the fseek

TMP_MAX
tmpnam

10

stderrstdin stdout
FILE

stdio.h

 &

int fclose(FILE *stream)

stream

void clearerr(FILE *stream)

stream

int feof(FILE *stream)

stream

int ferror(FILE *stream)

stream

int fflush(FILE *stream)

stream

int fgetpos(FILE *stream, fpos_t *pos)

stream pos

FILE *fopen(const char *filename, const char *mode)

mode filename

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)

stream ptr

FILE *freopen(const char *filename, const char *mode, FILE *stream)

filename stream

10

int fseek(FILE *stream, long int offset, int whence)

stream offset offset
whence

11

int fsetpos(FILE *stream, const fpos_t *pos)

stream pos fgetpos

12

long int ftell(FILE *stream)

stream

13

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)
ptr stream

14

int remove(const char *filename)

filename

15

int rename(const char *old_filename, const char *new_filename)

old_filename new_filename

16

void rewind(FILE *stream)

stream

17

void setbuf(FILE *stream, char *buffer)

stream

18

int setvbuf(FILE *stream, char *buffer, int mode, size_t size)

stream

19

FILE *tmpfile(void)
(wb+)

20

char *tmpnam(char *str)

21

int fprintf(FILE *stream, const char *format, ...)

stream

22

int printf(const char *format, ...)

stdout

23

int sprintf(char *str, const char *format, ...)

24

int vfprintf(FILE *stream, const char *format, va_list arg)

stream

25

int vprintf(const char *format, va_list arg)

stdout

26

int vsprintf(char *str, const char *format, va_list arg)

27

int fscanf(FILE *stream, const char *format, ...)

stream

28

int scanf(const char *format, ...)

stdin

29

int sscanf(const char *str, const char *format, ...)

30

int fgetc(FILE *stream)

stream

31

char *fgets(char *str, int n, FILE *stream)

stream str
(n-1)

32

int fputc(int char, FILE *stream)

char stream

33

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

stream

34

int getc(FILE *stream)

stream

35

int getchar(void)
stdin

36

char *gets(char *str)

stdin str

37

int putc(int char, FILE *stream)

char stream

38

int putchar(int char)

char stdout

39

int puts(const char *str)

stdout

40

int ungetc(int char, FILE *stream)

char stream

41

void perror(const char *str)

stderr str

C - <stdlib.h>

stdlib .h

stdlib.h

&

size_t
sizeof

wchar_t

div_t
div

ldiv_t
ldiv


stdlib.h

&

NULL

EXIT_FAILURE
exit

EXIT_SUCCESS
exit

RAND_MAX
rand

MB_CUR_MAX
MB_LEN_MAX

stdlib.h

&

double atof(const char *str)

str double

int atoi(const char *str)

str int

long int atol(const char *str)

str long int

double strtod(const char *str, char **endptr)

str double

long int strtol(const char *str, char **endptr, int base)

str long int

unsigned long int strtoul(const char *str, char **endptr, int base)
str unsigned long int

void *calloc(size_t nitems, size_t size)

void free(void *ptr

callocmalloc realloc

void *malloc(size_t size)

10

void *realloc(void *ptr, size_t size)

malloc or calloc ptr

11

void abort(void)

12

int atexit(void (*func)(void))

func

13

void exit(int status)

14

char *getenv(const char *name)

name

15

int system(const char *string)

string

16

void *bsearch(const void *key, const void *base, size_t nitems, size_t size, int
(*compar)(const void *, const void *))

17

void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *,
const void*))

18

int abs(int x)
x

19

div_t div(int numer, int denom)

20

long int labs(long int x)

x

21

ldiv_t ldiv(long int numer, long int denom)

22

int rand(void)
0 RAND_MAX

23

void srand(unsigned int seed)

rand

24

int mblen(const char *str, size_t n)

str

25

size_t mbstowcs(schar_t *pwcs, const char *str, size_t n)

str pwcs

26

int mbtowc(whcar_t *pwc, const char *str, size_t n)

str

27

size_t wcstombs(char *str, const wchar_t *pwcs, size_t n)

pwcs str

28

int wctomb(char *str, wchar_t wchar)

wchar

C - <string.h>

string .h

string.h

&
size_t
sizeof

string.h

&
NULL

string.h

&

void *memchr(const void *str, int c, size_t n)

str n c

int memcmp(const void *str1, const void *str2, size_t n)

str1 str2 n

void *memcpy(void *dest, const void *src, size_t n)

src n dest

void *memmove(void *dest, const void *src, size_t n)

str2 n str1

void *memset(void *str, int c, size_t n)

c str n

char *strcat(char *dest, const char *src)

src dest

char *strncat(char *dest, const char *src, size_t n)

src dest n

char *strchr(const char *str, int c)

str c

int strcmp(const char *str1, const char *str2)

str1 str2

10

int strncmp(const char *str1, const char *str2, size_t n)

str1 str2 n

11

int strcoll(const char *str1, const char *str2)

str1 str2 LC_COLLATE

12

char *strcpy(char *dest, const char *src)

src dest

13

char *strncpy(char *dest, const char *src, size_t n)

src dest n

14

size_t strcspn(const char *str1, const char *str2)

str1 str2

15

char *strerror(int errnum)

errnum

16

size_t strlen(const char *str)

str

17

char *strpbrk(const char *str1, const char *str2)

str1 str2
s1s2

18

char *strrchr(const char *str, int c)

str c

19

size_t strspn(const char *str1, const char *str2)

str1 str2

20

char *strstr(const char *haystack, const char *needle)

haystack needle


21

char *strtok(char *str, const char *delim)

str delim

22

size_t strxfrm(char *dest, const char *src, size_t n)

LC_COLLATE src n
dest

C - <time.h>

time.h

time.h

&

size_t
sizeof

clock_t

time_t is

struct tm

tm
struct
int
int
int
int
int
int
int
int
int
};

tm {
tm_sec;
tm_min;
tm_hour;
tm_mday;
tm_mon;
tm_year;
tm_wday;
tm_yday;
tm_isdst;

/*
/*
/*
/*
/*
/*
/*
/*
/*

0 59
*/
0 59
*/
0 23
*/
1 31 */
0 11
*/
1900
*/
0 6
*/
0 365 */

*/

 time.h

&

NULL

CLOCKS_PER_SEC

time.h

&

char *asctime(const struct tm *timeptr)

timeptr

clock_t clock(void)

char *ctime(const time_t *timer)

timer

double difftime(time_t time1, time_t time2)

time1 time2 (time1-time2)

struct tm *gmtime(const time_t *timer)

timer tm UTC
GMT

struct tm *localtime(const time_t *timer)

timer tm

time_t mktime(struct tm *timeptr)

timeptr time_t

size_t strftime(char *str, size_t maxsize, const char *format, const struct tm
*timeptr)
format timeptr
str

time_t time(time_t *timer)

time_t

W3School
W3School