Moät soá kieán thöùc cô sôû veà laäp trình baèng ngoân ngöõ C

Muïc luïc

Phuï luïc: Toùm taét

Töø khoùa C

auto

double

int

struct

break

else

long

switch

case

enum

register

typedef

char

extern

return

union

const

float

short

unsigned

continue

for

signed

void

default

goto

sizeof

volatile

do

if

static

while

 

Toùan töû

Moät soá toaùn töû ñaëc tröng cuûa C caàn nhô ù:

TT

Moâ taû

TT

Moâ taû

=

Pheùp gaùn

>=

Lôùn hôn hoaëc baèng

 

+=

Pheùp gaùn coäng

<=

Nhoû hôn hoaëc baèng

-=

Pheùp gaùn tröø

sizeof

Kích thöôùc cuûa (bieán)

*=

Pheùp gaùn nhaân

&&

AND (logic)

/=

Pheùp gaùn chia

||

OR (logic)

%=

Pheùp gaùn modulo

!

NOT (logic)

-

Daáu aâm

&

AND (bit)

++

Taêng 1

|

OR (bit)

--

Giaûm 1

^

NOT (bit)

==

Baèng (logic)

~

Phaàn buø (bit)

!=

Khoâng baèng (logic)

>>

Dòch phaûi 1 bit

>

Lôùn hôn

<<

Dòch traùi 1 bit

<

Nhoû hôn

?:

Toaùn töû ñieàu kieän

 

Haèng

Haèng nguyeân:
            ôû ñuoâi u hay U : unsigned
            ôû ñuoâi l hay L : long
            ôû ñaàu 0 (khoâng): octal
            ôû ñaàu 0x hay 0X: hexa

Haèng kyù töï: ‘A’, ‘c’,…
Moät soá kyù töï ñaëc bieät:

Kyù töï

YÙ nghóa

Kyù töï

YÙ nghóa

\a

Audible alert

\v

Vertical tab

\b

Backspace

\"

Double quote

\f

Form feed

\'

Single quote

\n

New line

\0

Null

\r

Carriage return

\\

Backslash

\t

Horizontal tab

 

 

\N

Octal constant (Here N is an octal constant.)

\xN

Hexadecimal constant (Here N is a hexadecimal constant.)

 

Haèng soá thöïc vôùi ñuoâi

 f, F, l, hay L ñeà bieåu dieãn float hay long double.
Haèng soá thöïc khoâng coù ñuoâi maëc ñònh laø double.


Haèng soá thöïc coù theå bieåu dieãn daïng soá muõ e hoaëc E.

 

 
float  flt_num = 1234.56f;
double  db_num = 1234.56;

Haèng chuoãi kyù töï ñöôïc giôùi haïn giöõa 2 daáu “”. C töï ñoäng theâm \0 vaøo cuoái string.

Kieåu döõ lieäu

data_type   variable_name_list;

Kieåu maûng

data-type  array-name[array-size];

Kieåu enum

enum tag_name {enumeration_list} variable_list;

Kieåu caáu truùc

struct struct_tag {
     data_type1 variable1;
     data_type2 variable2;
     data_type3 variable3;
     .
     .
     .
     };

Ví duï:

struct automobile {
     int year;
     char model[8];
     int engine_power;
     float weight;
     };

Kieåu union

union union_tag {
     data_type1 variable1;
     data_type2 variable2;
     data_type3 variable3;
     .
     .
     .
     };

Ví duï:

union automobile {
     int year;
     char model[8];
     int engine_power;
     float weight;
};

Ñònh nghóa kieåu baèng typedef

Ví duï:

typedef  int  TWO_BYTE;

Duøng khai baùo nhö sau

TWO_BYTE i, j;

Töông ñöông

 
int i, j;

Bieåu thöùc vaø caâu leänh

Caâu leânh trong C laø taäp hôïp bieåu thöùc coù nghóa keát thuùc bôûi (;).
Khoái caâu leänh laø nhoùm caâu leänh giöõa 2 ngoaëc { vaø }. C xöû lyù khoái caâu leänh nhö laø moät caâu leänh.

A group of statements can form a statement block that starts with an opening brace ({) and ends with a closing brace (}). The C compiler treats a statement block as a single statement.

Leänh ñieàu khieån

Leänh laëp:

for (expression1; expression2; expression3) {
   statement1;
   statement2;
   .
   .
   .
}
 
 
for ( ; ; ){
  /* statement block */
}
 
while (expression) {
   statement1;
   statement2;
   .
   .
   .
}
 
 
while (1) {
   /* statement block */
}
 
 
do {
   statement1;
   statement2;
   .
   .
   .
} while (expression);

Leänh ñieàu kieän reõ nhaùnh:

if (expression) {
   statement1;
   statement2;
   .
   .
   .
}
 
 
if (expression) {
   statement1;
   statement2;
   .
   .
   .
}
else {
   statement_A;
   statement_B;
   .
   .
   .
}
 
 
switch (expression) {
   case expression1:
        statement1;
   case expression2:
        statement2;
   .
   .
   .
   default:
        statement-default;
}
 
Leänh goto:
 
label-name:
   statement1;
   statement2;
   .
   .
   .
   goto  label-name;

Con troû

 
data-type  *pointer-name;

pointer-name chæ giaù trò ñòa chæ trong boä nhôù (giaù trò traùi) vaø * pointer-name laø noäi dung chöùa trong phaàn boä nhôù ñaëc taû bôûi data-type (giaù trò phaûi).

Toùan töû dereference * traû laïi noäi dung cuûa bieán,
Toaùn töû & traû laïi ñòa chæ cuûa bieán.

Con troû chæ ñeán ñoái töôïng
Coù theå tieáp caän ñeán 1 phaàn töû cuûa maûng baèng con troû chæ ñeán phaàn töû ñaàu tieân cuûa maûng.

ptr_array = an_array;
 
bieåu thöùc
 
an_array[n]

töông ñöông

 
*(ptr_array + n)

Nhieàu luùc coù theå ñònh nghóa maûng pointer

int *ptr_int[3];
 
hoaëc pointer troû ñeán moät caáu truùc
 
struct computer {
   float cost;
   int year;
   int cpu_speed;
   char cpu_type[16];
};

nhö sau

 
struct computer *ptr_s;

Ta coù theå tieáp caän ñeán caùc phaàn töû caáu truùc:

 
(*ptr_s).year = 1997;
 
ptr_s->year = 1997;

Haøm

data_type_specifier  function_name(
      data_type_specifier argument_name1,
      data_type_specifier argument_name2,
      data_type_specifier argument_name3,
      .
      .
      .
      data_type_specifier argument_nameN,
);

Xuaát vaø nhaäp

Caùc leänh xuaát vaø nhaäp vôùi caùc teäp thoâng qua stream (file).

Coù 3 file stream ñöôïc môû tröôùc cho ngöôøi söû duïng:

Caáu truùc FILE  ñöôïc ñònh nghóa trong stdio.h. Con troû tyùp FILE goïi laø file pointer vaø tham chieáu ñeán moät teäp treân ñóa.

FILE *fptr;

Caùc leänh thoâng duïng ñeå ñieàu khieån thao taùc xuaát nhaäp:  fopen(), fclose(), fgetc(), fputc(), fgets(), fputs(), fread(), fwrite(), feof(), fscanf(), fprintf(), fseek(), ftell(), rewind(), and freopen()…

C Preprocessor

C preprocessor khoâng phaûi laø moät phaàn cuûa boâ bieân dòch C, noù chaïy tröôùc khi boä bieân dòch hoaït ñoäng vaø coù nhieäm vuï thay nhöõng leänh macro baèng nhöõng ñoaïn maõ töông öùng trong nhöõng file thö vieän.

Caùc leänh macro ñeå ñieàu khieån C preprocessor: #define, #undef, #ifdef, #ifndef, #endif, #if, #elif, vaø #else.

Muïc luïc