SuP S1-2. Recapitulare C

Sisteme cu microprocesoare Limbajul C
Seminar
Recapitulare
Limbaj C
©A.Sarca SuP S - 1
Bibliografie
C – general
• Kernighan B., Ritchie D. – The C Programming Language, Prentice
Hall
C si embedded systems
• Barr M., Programming Embedded Systems in C and C++, O’Reilly,
1999
• Zurell K., C Programming for Embedded Systems, R&D Books,
2000
• Craft B., First Steps with Embedded Systems, 2002
• Labrosse J., Embedded System Building Blocks, R&D Books,
2000
• Ganssle J., The Art of Designing Embedded Systems, Accademic
Press
Altele
• McConnell St., Code Complete, Microsoft, 2004
• Qualline St., Practical C Programming, O’Reilly, 1997
©A.Sarca SuP S - 2
Tipuri, operatori, expresii
1. Numele variabilelor
• Litere, cifre, underscore ( _ )

• Case sensitive! Alfa sau alfa nu e același lucru!
• Nume sugestive – corelat cu rolul în program
• Uzual, nume scurte pt. variabile locale, lungi pt. cele externe
Exemple:
int alfa, beta;
float x, speed, temperature;
char MyName[20];
long position_count;
©A.Sarca SuP S - 3
2. Tipuri de date, dimensiuni
• Tipuri de bază:
– int – întreg, corelat cu procesorul utilizat (uzual, 16 biți) [-32768; 32767]
– float – virgula mobila, simplă precizie (32 biți) [1.2E-38; 3.4E+38]
– double – virgula mobila, dublă precizie (64 biți) [2.3E-308; 1.7E+308]
– char – un caracter (1 octet = 8 biți) [-128; 127]
• Tipuri aditionale:
– short int – întreg scurt, tipic 8 biți dacă int este de 16 biți. Dacă nu este suportat
va fi la fel ca int
– long int – întreg lung, tipic 32 biți dacă int este de 16 biți. Dacă nu este suportat
va fi la fel ca int
– signed int – la fel ca int
– unsigned int – întreg fără semn [0; 65535]
– long double – virgulă mobilă, precizie mai mare decât double
Exemple:
double field[1000];
unsigned int a = 230;
©A.Sarca SuP S - 4
3. Constante
• Intreg: 1234
• Long: 334512356L
• Hexazecimal: 0xA123
• Caracter: ’A’ – codul ASCII al literei A , 1 caracter (octet)
• String: “Data Nasterii” – un șir cu caracterele din text, plus
caracterul null ‘\0’ la final
• Escape sequence: ‘\n’ . Caracter de control: linie nouă
• Enumerări: enum boolean { NO, YES } (primul=0, al doilea=1, etc.)
Exemple:
#define PI 3.141528
#define MAXINDEX 100
i[MAXINDEX+3] = 77;
if (a == YES)
x = 100;
©A.Sarca SuP S - 5
4. Declarații
int minim, maxim, interval;
char c, nume[100];
echivalent cu
char c;
char nume [100];
int i = 0;
int interval = BAZA + 1;
float two_pi = 2 * PI;
const double e = 2.71828182845905;
©A.Sarca SuP S - 6
5. Operatori aritmetici
+ Adunare
- Scădere
* înmulțire
/ împărțire
% modulo (rest împărțire)
Exemple:
x = a + 3;
y = b/2 * a/3;
zeta = zi % 7;
©A.Sarca SuP S - 7
6.a Operatori relaționali
> Mai mare

>= Mai mare sau egal
< mai mic
<= mai mic sau egal
== egal
!= diferit (inegal)
Exemple:
if(i <=7)
a = 12;
while(a != 100)
{ a = a +1;}
if (speed == MAXSPEED)
stop = TRUE; ©A.Sarca SuP S - 8
6.b Operatori logici
&& ȘI logic A B A && B A B A || B
|| SAU logic 0 0 0 0 0 0
0 1 0 0 1 1
dacă TRUE, rezultatul e egal cu 1;
1 0 0 1 0 1
dacă FALSE, rezultatul e egal cu 0
1 1 1 1 1 1
Exemple:
if(i <=7 && j!=0)
a = 12;
while(a != 100 || b<32)
{ a = a +1; b=b-2;}
if (speed == MAXSPEED)
stop = TRUE;
Prioritate operatori:
High > >= <= <
== !=
&&
Low ||
Exemplu:
for(i=0; i<lim-1 && (c=getchar()) != ‘x’ && c != ‘y’; i++)
©A.Sarca SuP S - 9
7. Conversii de tip
/* atoi: conversie caracter în întreg */
int atoi(char s)
{
int n;
n = s - ’0’;// ‘0’=48 in decimal
return n;
}
/* lower: conversie litere mari în litere mici */

int lower(int c)
{
if (c >= ’A’ && c <= ’Z’)
return c + ’a’ - ’A’;
else
return c;
}
©A.Sarca SuP S - 10
7. Conversii de tip (continuare)
Regula generală: în expresie cu 2 operanzi de tip diferit, cel de tip ‘inferior’
este convertit automat la tipul ‘superior’:
- dacă un operand e long double, se convertesc la long double

altfel,
- dacă un operand e double, se convertesc la double
altfel,
- dacă un operand e float, se convertesc la float
altfel,
- se convertește char și short la int
iar dacă oricare operand e long, se convertesc la long
Asignări: expresia din stânga e convertită la tipul rezultatului
7. Conversii de tip (continuare)
int i, j;
float x, y;
i = x; /* conversie float la întreg, trunchiere */
x = i; /* conversie întreg la float */
Forțare tip în expresii:

y = x + float(i) / j; /* împărțirea i la j se face în float, fără trunchiere */
y = x + i / j; /* împărțirea i la j se face în întregi (trunchiere), apoi se

convertește la float! */
8. Operatori de incrementare și decrementare
++ incrementare(adunare cu 1)
-- decrementare(scădere cu 1)
Utilizați ca prefix (înainte de operand) –întăi
incrementez/decrementez, apoi se utilizează operandul
Exemplu:
i = 3;
a = ++i + 2; /* a va avea valoarea 6, i valoarea 4 */
Utilizați ca sufix (după operand) – întăi se utilizează operandul în

expresie, apoi incrementez/decrementez
Exemplu:
i = 3;
a = 2 + i++; /* a va avea valoarea 5, i valoarea 4 */
9. Operatori la nivel de biți
& ȘI logic
| SAU logic
^ SAU Exclusiv
<< deplasare la stânga
>> deplasare la dreapta
~ complement (one’s complement)
& - utilizat pentru mascare biți (biți = 0)

Ex: n = n & 0x30; /* 0x30 = 00110000 anulează toti biții, exceptie
bitul 4 și 5 */
| - utilizat pentru setare biți (biți = 1)

Ex: n = n | 0x30; /* setează biții 4 și 5, lasa ceilalți nemodificați */
9. Operatori la nivel de biți (continuare)
<< utilizat pentru deplasare la stânga;
Exemplu:
n = n << 2; /* deplasare la stânga cu 2 biți; se pierd biții din
stânga, se introduc doi biți de 0 în dreapta. Echivalent cu înmulțire
cu 2^2 */
>> utilizat pentru deplasare la dreapta;

Exemplu:
n = n >> 3; /* deplasare la dreapta cu 3 biți; se pierd biții din
dreapta, se introduce trei biți de 0 SAU de semn!!! in stanga – in
functie de tipul variabilei! Echivalent cu impartire cu 2^3 */
~ utilizat pentru a nega biții unei variabile(schimbă biți 0 în 1 și 1 în 0)

Exemplu:
x = ~x
~ 00100011 = 35 (în zecimal)
________
11011100 = 220 (în zecimal)
10. Operatori de asignare, expresii
x = x + 2; /* este echivalent cu x += 2; */
În general
expr 1 op= expr 2
e echivalent cu
expr 1 = (expr 1) op (expr 2 )
unde op poate fi + - * / << >> & ^ ~
Exemplu:
x *= y + 1; /* e echivalent cu x = x * (y +1) */
11. Expresii condiționale
if( a > b)
z = a;
else
z = b;
alternativ:
expr 1 ? expr 2 : expr 3
evaluează expr1. Dacă e diferită de 0 (TRUE), se atribuie valoarea
expr2. Dacă e 0 (FALSE), se atribuie valoarea expr3
Exemplu:
z = (a>b) ? a:b; /* este echivalent cu z = max(a,b) */
12. Precedență și ordinea evaluării expresiilor
12. Precedență și ordinea evaluării expresiilor (continuare)
A se utiliza paranteze pentru a obține rezultate corecte!

if ((x & MASK) == 0) ...
Atenție la situațile când ordinea evaluârii unor expresii nu e clară!
x = f() + g(); /* posibil să se apeleze întâi f(), SAU g() . Dacă f sau g modifică o
variabilă globală utilizată și în cealaltă funcție, efectele pot fi nepredictibile! */
a[i] = i++; /* nu se știe dacă se modifica și indicele din tablou unde se memorează i
– depinde de compilator, etc. */
Concluzie: a NU se scrie cod în care pot apărea situații ambigue în care
ordinea evaluării unor expresii e nesigură!
Controlul programului
1.Instrucțiuni
Instrucțiuni: expresii, urmate de ‘;’

x=0;
i++;
swap(x,y);
Instrucțiuni compuse: grup de instrucțiuni între ‘{‘ și ‘}’
if(a==0) {
x=1;
y=2;
}
else {
x=2;
y=1;
}
2. Decizii
if-else înlănțuite - else asociat
instrucțiunii if precedente
If-Else
if (n > 0)
if (expresie) if (a > b)
instrucțiune z = a;
else else
instrucțiune z = b;
Utilizare ‘{‘ și ‘}’ pentru claritate sau alte
else – opțional, poate fi omis condiții
if (n > 0) {
Testul condiției este echivalent
if (a > b)
cu
z = a;
if (expresie != 0) }
else
z = b;
2.Decizii (continuare)
if-else înlănțuite – continuare
if (n > 0) if (n > 0) {
for (i=0; i < n; i++) for (i=0; i < n; i++)
if (s[i] > 0) { if (s[i] > 0) {
printf(“…”); printf(“…”);
return i; return i;
}
}
}
else
else
printf (“error! n is negative!”); printf (“error! n is negative!”);
NU e corect! else se aplica la if(s[i]…,NU

la if (n>0)
Utilizare ‘{‘ și ‘}’ pentru claritate
Else if
if (expresie) if (n > 10)

instrucțiune a = 10;
else if (expresie) else if (n < -10)
instrucțiune a = -10;
else if (expresie) else if (n < 0)
a = -n;
instrucțiune
else
else a = n;
instrucțiune
switch (x) {
Switch case 1: case 2:
a = 10;
switch (expresie) { b = 1;
case expresie-constanta: break;
instrucțiuni case 5:
case expresie-constanta: a = 5; /* lipsește ‘break’,
instrucțiuni continuă! */
default: instrucțiuni case 6:
} b = 2;
break;
default:
a = 0;
b = 0;
}
3.Bucle
while ((c = getchar()) == ‘ ‘)
while și for ; /* elimin caracter
spațiu */
while (expresie)
instrucțiune for (i = 0; i < n; i++)
…
/* Dacă expresie adevarată,
execută instrucțiune */ #include <string.h>
______________________________________ /* reverse: reverse string s in place */
for (expr1; expr2; expr3) void reverse(char s[])
instrucțiune {
int c, i, j;
instrucțiunea for e echivalentă cu for (i = 0, j = strlen(s)-1; i < j; i++, j--)
{
expr1; c = s[i];
while (expr2) { s[i] = s[j];
instrucțiune s[j] = c;
expr3; }
} }
3.Bucle (continuare)
/* găsire primul spațiu într-un string */
int position, i;
Break; Continue
for (i = 0; i < n; i++ )
if (a[i] = ‘ ‘)
break – forțează ieșirea din break;
bucle for, while, do, switch position = i;
- se iese din bucla interioară
for (i = 0; i < n; i++)

continue – forțeaza o nouă if (a[i] < 0) /* sare peste elementele
iterație în bucle for, while sau negative*/
do continue;
... /* analiză elemente pozitive*/
3.Bucle (continuare)
Goto; etichete (labels) for ( ... )

for ( ... ) {
goto – forțeaza ieșirea din bucle ...
if (disaster)
A se utiliza goto doar în cazul unor goto error;
bucle multiple, pentru ieșire
}
forțată, unde break nu se poate
folosi! ...
error:
Eticheta: nume ca o variabila, urmat /* clean up the mess */
de ‘:’
Valabilă (scope) în interiorul funcției

curente
Structura programului
1.Funcții
Sintaxa: double sum(double a, b)

tip variabilă returnată nume_funcție (lista_declarații_argumente) {
{ double s = a + b;
declarații și instrucțiuni
} return s;
}
tip variabilă returnată – dacă nu e specificat, se consideră int …
Instrucțiunea return în funcție – opțională
main ()
Definire consistentă a funcției: {
tipul și argumentele de acelasi tip la definire double x, y, suma;
și la apelare
x = 1.23;
O funcție nu poate fi definită în interiorul altei funcții! y = 2.e-5;
suma = sum(x , y);
Prototype: necesar dacă funcția e definită în alt fișier }
Definește funcția, dar nu conține codul acesteia:
tip variabilă returnată nume_funcție (lista_declaratii_argumente);
1.Funcţii (continuare)
Mai multe fișiere
Totul în același fișier Fișier 1:
(întâi definită funcția, apoi, apelată!) /* definierea funcției */
double sum(double a, b)
double sum(double a, b) {
{ double s = a + b;
double s = a + b; return s;
return s; }
} Fișier 2:
… double sum(double a, b); /* prototype
main () funcție definită în altă parte*/
{ main ()
double x, y, suma; {
x = 1.23; double x, y, suma;
y = 2.e-5; x = 1.23;
suma = sum(x , y); y = 2.e-5;
} suma = sum(x , y);
}
2.Variabile externe
IMPORTANT! O variabilă globală poate fi DEFINITĂ ÎNTR-UN SINGUR LOC
din program! Ea trebuie DECLARATĂ în orice loc (fișier) în care va fi
folosită, ÎNAINTE de a fi referită în cod (dacă nu este definită acolo).
…
Fisier 1 void main()
/* definire variabile a și b, li se alocă memorie */ {
int a = 10, b = 100; int u, v, w;
Int f4(int x, int y); /* prototype funcție externâ */ u = f1(5); /* u = 50 */
… v = f2(10); /* v = 1100 */
int f1(int x) w = f3(1,2); /* w = 6; a = 3 */
{ u = f1(5); /* u = 15 ! */
return a * x; v = f4(1, 2); /* v = 16; a = 8; */
} }
int f2(int x) Alt fisier:
{ /* declarară tip și nume variabile, NU alocă
return (a + b) * x; memorie */
} extern int a, b;
int f3 (int x, int y) int f3(int m, int n); /* prototype funcție f3 */
{ void f4(int x, int y)
a = x + y; /* atentie, modifica pe a */ {
return 2*a; int uu = f3(2*x, 3*y);
} return uu;
}
3.Fișiere header
4.Variabile statice
Variabile statice – valabile doar în fișierul în care sunt definite.
Pot folosi același nume de variabilă și în alt fișier.
Fișier 1 Alt fișier:
/* definire variabile statice a și b */ /* definire alte variabile statice a
static int a = 10, b = 100; și b */
int f4(int x, int y); /* prototype f4 */
static int a = 30, b = 50;
int f3 (int x, int y)
{ void f4(int x, int y)
a = x + y; /* atenție, modifică pe {
a */ int uu = f3(a*x, b*y);
return 2*a; return uu;
} }
…
void main()
{
int w = f3(1,2); /* w = 6; a = 3 */
int u = f4(1, 2); /* u = 130; */
}
5.Scope = valabilitate
Variabile de tip registru:
register int x; /* sugerează compilatorului să aloce
variabila într-un registru al procesorului */
Valabilitate (scope) a unei variabile – blocuri

if (n > 0) {
int i; /* i e valabil doar în ramura ‘TRUE’ a IF */
for (i = 0; i < n; i++)
...
}
int x;
int y;
f(double x)
{
double y;
}
6.Recursivitate
Recursivitate (funcții reentrante):
#include <stdio.h>
/* printd: print n în decimal */
void printd(int n)
{
if (n < 0) {
putchar('-');
n = -n;
}
if (n / 10)
printd(n / 10);
putchar(n % 10 + '0');
}
7.Preprocesorul C
Includerea de fișiere
#include “nume_fisier”- caută uzual de unde e sursa programului, +
#include <nume_fisier>- caută după reguli specifice de implementare
Definire macro simplu (fără argumente)

#define nume text_inlocuire
inserează exact textul definit in cod!
Definire macro cu argumente
#define max(A, B) ((A) > (B) ? (A) : (B) )
Linia de program
x = max(p+q, r+s);
generează codul urmator
x = ((p+q) > (r+s) ? (p+q) : (r+s));
7.Preprocesorul C (continuare)
Includerea condiționată
#if !defined(HDR) #if SYSTEM == SYSV

#define HDR #define HDR "sysv.h"
/* contents of hdr.h go here */ #elif SYSTEM == BSD
#endif #define HDR "bsd.h"
#elif SYSTEM == MSDOS
#ifndef HDR #define HDR "msdos.h"
#define HDR #else
/* contents of hdr.h go here */ #define HDR "default.h"
#endif #endif
#include HDR
Pointeri
Pointer: variabilă ce conține adresa unei variabile
Pointerul p este în sine un tip special de
variabilă, memorată într-o locație de
memorie (de ex., la adresa 100)
100 1200
Valoarea pointerului p (valoarea care se
găsește la adresa unde este pointerul),
reprezintă adresa unei variabile (de ex.,
1200 este adresa la care se găsește
variabila pe care o referă pointerul din 1200 1234
figura alaturată).
Utilizând pointerul p se poate accesa (citi,

scrie) variabila de la adresa 1200
Exemplu:
int *ip; /* definire pointer la un întreg */
ip = 1200; /* se setează valoarea pointerului la 1200 */
*ip = 1234; /* se seteaza conținutul memoriei de la adresa 1200 cu valoarea 1234 */
Pointeri
Operatorul & dă adresa unui obiect definit:
p = &c;
valoarea pointerului p este setată cu adresa variabilei c
Operatorul * (indirectare) – aplicat unui pointer, permite accesul la

obiectul pe care îl indică pointerul
int x = 1, y = 2, z[10];
int *ip; /* ip is a pointer to int */
ip = &x; /* ip now points to x */
y = *ip; /* y is now 1 */
*ip = 0; /* x is now 0 */
ip = &z[0]; /* ip now points to z[0] */
Pointeri
*ip = *ip + 10; /* adună 10 la valoarea referită de pointerul ip */
y = *ip + 1 ; /* adaugă 1 la valoarea referită de pointerul ip,

salvează rezultatul în variabila y */
ip += 1; /* ip pointer; incrementare ip; ip referă locația

următoare de memorie */
++*ip; /* incrementare cu 1 valoarea referită de pointerul ip */
(*ip)++ /* la fel, dar paranteză necesară */
iq = ip; /* ip, iq pointeri; iq va referi aceeași variabilă ca și ip */
Pointeri
Pointeri și argumentele funcților
Argumentele câtre funcții sunt transmise prin valoare: la apelare funcție, se
transmit funcției valorile parametrilor. Orice modificare a acestora în funcție NU
modifică valorile acestora în locul de unde se apelează funcția. Exemplu:
void swap(int x, int y) /* WRONG */ void swap(int *px, int *py) /* OK */
{ {
int temp; int temp;
temp = x; temp = *px;
x = y; *px = *py;
y = temp; *py = temp;
} }
… un apel de genul … un apel de genul
int a = 1; int b = 2; int a = 1; int b = 2;

swap (a, b); swap (&a, &b);
NU va putea fi folosit pentru a va putea fi folosit pentru a interschimba

interschimba cele două valori a și b cele două valori a și b
Pointeri
Pointeri și tablouri (arrays) – legatură directă
int a[10];
Definește un tablou de 10 elemente (consecutive în memorie), a[0], a[1], … a[9]
a[0] a[9]
a:
a[0]
pa:
int *pa; &a[i] e echivalent cu a+i

pa = &a[0]; /* pa conține adresa lui a[0] */ pa[i] e echivalent cu *(pa+i)
x = *pa; /* setează x cu a[0] */ Corect
y = *(pa +4); /* setează y cu a[4] */ pa = a;
Se putea scrie și pa++;
pa = a; /* pa conține adresa lui a[0] */ Incorect
*(a+i) e echivalent cu a[i] a = pa;
a++;
Pointeri
Pointeri și tablouri (arrays) - Exemplu
Utilizare array: Utilizare pointer:

/* strlen: return length of s */ /* strlen: return length of string s */
int strlen(char s[]) int strlen(char *s)
{ {
int i; int i;
while (s[i] != '\0') for (i = 0; *s != '\0', s++)
++i; i++;
return i; return i;
} }
Apelare (oricare, sunt echivalente):

strlen("hello, world"); /* string constant */
strlen(array); /* char array[100]; */
strlen(ptr); /* char *ptr; */

SuP S1-2. Recapitulare C

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

SuP S1-2. Recapitulare C

Încărcat de

Drepturi de autor:

Formate disponibile

Sisteme cu microprocesoare Limbajul C

• Litere, cifre, underscore ( _ )

const double e = 2.71828182845905;

> Mai mare

/* lower: conversie litere mari în litere mici */

- dacă un operand e long double, se convertesc la long double

iar dacă oricare operand e long, se convertesc la long

Asignări: expresia din stânga e convertită la tipul rezultatului

x = i; /* conversie întreg la float */

Forțare tip în expresii:

y = x + i / j; /* împărțirea i la j se face în întregi (trunchiere), apoi se

Utilizați ca sufix (după operand) – întăi se utilizează operandul în

& - utilizat pentru mascare biți (biți = 0)

| - utilizat pentru setare biți (biți = 1)

>> utilizat pentru deplasare la dreapta;

~ utilizat pentru a nega biții unei variabile(schimbă biți 0 în 1 și 1 în 0)

unde op poate fi + - * / << >> & ^ ~

12. Precedență și ordinea evaluării expresiilor (continuare)

A se utiliza paranteze pentru a obține rezultate corecte!

Atenție la situațile când ordinea evaluârii unor expresii nu e clară!

Instrucțiuni: expresii, urmate de ‘;’

Instrucțiuni compuse: grup de instrucțiuni între ‘{‘ și ‘}’

if-else înlănțuite – continuare

NU e corect! else se aplica la if(s[i]…,NU

if (expresie) if (n > 10)

for (i = 0; i < n; i++)

Goto; etichete (labels) for ( ... )

Valabilă (scope) în interiorul funcției

Sintaxa: double sum(double a, b)

Valabilitate (scope) a unei variabile – blocuri

Recursivitate (funcții reentrante):

Definire macro simplu (fără argumente)

Definire macro cu argumente

#define max(A, B) ((A) > (B) ? (A) : (B) )

#if !defined(HDR) #if SYSTEM == SYSV

Utilizând pointerul p se poate accesa (citi,

Operatorul * (indirectare) – aplicat unui pointer, permite accesul la

*ip = *ip + 10; /* adună 10 la valoarea referită de pointerul ip */

y = *ip + 1 ; /* adaugă 1 la valoarea referită de pointerul ip,

ip += 1; /* ip pointer; incrementare ip; ip referă locația

++*ip; /* incrementare cu 1 valoarea referită de pointerul ip */

(*ip)++ /* la fel, dar paranteză necesară */

iq = ip; /* ip, iq pointeri; iq va referi aceeași variabilă ca și ip */

int a = 1; int b = 2; int a = 1; int b = 2;

NU va putea fi folosit pentru a va putea fi folosit pentru a interschimba

int *pa; &a[i] e echivalent cu a+i

Utilizare array: Utilizare pointer:

Apelare (oricare, sunt echivalente):

S-ar putea să vă placă și

ip = ip + 10; /* adună 10 la valoarea referită de pointerul ip */

y = ip + 1 ; / adaugă 1 la valoarea referită de pointerul ip,

++ip; / incrementare cu 1 valoarea referită de pointerul ip */

(ip)++ / la fel, dar paranteză necesară */