Sunteți pe pagina 1din 7

4.

Operatorul << inseamna shiftare la stanga.

8 = 1000
(baza 10) (baza 2)

Cand faci shiftare la stanga inseamna ca adaugi zerouri in partea din stanga. In
cazul de fata se adauga 3 zerouri si rezultatul devine: 1000000

1000000 = 64
(baza 2) (baza 10)

Ca sa iti fie mai usor poti considera shiftarea la stanga o inmultire cu 2. In


cazult nostru se shifteaza la stanga cu 3 unitati adica 8*2*2*2 = 64

-----------------------------------------------------------------
7.
Numele variabilei poate sa contina cifre(dar nu numai cifre, trebuie sa existe cel
putin o litera ca altfel se considera ca fiind un numar), lirete mici si mari si
underline.

Numele variabilei poate sa fie de felul urmator:


asd
ASD
Asd
A_SD
A_123
123_A_a
etc

Numele variabilei poate NU sa fie de felul urmator:


1254 - gresit, compilatorul considera asta un numar nu un nume de
variabila
asf*|-d - gresit!!!!

* inseamna inmultire intre 2 operanzi


| inseamna SAU pe biti intre 2 operanzi
- inseamna scardere intre 2 operanzi
Poti afla mai multe despre operatiile pe biti din linkul de mai jos:
http://www.worldit.info/articole/algoritmica-articole/tips-tricks-operatii-pe-biti/

-----------------------------------------------------------------
9.

#define Multiply(a, b) a*b


Linia mai sus se numeste directiva de precompilare. #define iti inlocuieste practic
in cod "Multiply(a, b)" cu "a*b". Adica unde gaseste defineul pune acolo inmuntirea
aceea.

Explicatie #define:
#define Asd 50

Cand se intalneste #define se ia primul sir de caractere de dupa "#define" si se


inlocuieste cu al doilea sir de caractere.
Dupa cum observi, "Asd" este primul sir de caractere apoi urmeaza un spatiu apoi
"50".
Peste tot in cod unde gaseste "Asd" compilatorul inlociueste cu "50".

In cazul tau:
#define Multiply(a, b) a*b
Peste tot unde gaseste "Multiply(a, b)" se inlocuieste cu "a*b".
Compilatorul este destept si stie ca:
a = (op1+1)
b = (op2+2)

In exemplul tau:
op1 = 12;
op2 = 5;
x = 0;

Apoi linia asta:


x = Multiply(op1+1, op2+2);
Se transforma in asta:
x = (op1+1)*(op2+2); - pasul 1 (aici se face practic inlocuirea aceea)
x = (12+1)*(5+2); - pasul 2
x = (13)*(7); - pasul 3
x = (12+1)*(5+2); - pasul 4
x = 91 - pasul 5

Ca sa iti dau alt exemplu poti considera:


#define DefineTEST(a, b) a-b+100

x = DefineTEST(op1+1, op2+2);
se transforma in asta:
x = (op1+1)-(op2+2)+100; - pasul 1
x = (12+1)-(5+2)+100; - pasul 2
x = (13)-(7)+100; - pasul 3
x = 106 - pasul 4

-----------------------------------------------------------------
10.

Programul in C are o executie secventiala, el executa liniile de sus in jos. Deci


programul tau va rula asa:

int Func1(void)
{
int a = 30; - pasul 1
int b = 9 - a / 5; - pasul 2
int c; - pasul 3

c = b * 4; - pasul 4
if (c > 10) { - pasul 5
c = c - 10; - pasul 6
}
return c * (60 / a); - pasul 7
}

- pasul 1:
a = 30
- pasul 2:
b = 9-30/5
Inmultirea si impartirea sunt ca la matematica, adica sunt mai prioritare decat
adunarea sau scaderea.
Pasul 2 se transforma automat in asta:
b = 9-(30/5) - adica se face mai intai impartirea aia
b = 9-6
b = 3

- pasul 3:
Aici se aloca spatiu pentru variabila "c", adica ea se creeaza. Daca ea nu este
intializata (adica daca nu se zice ca este = cu ceva) ea se intializeaza automat cu
0.

c = 0

- pasul 4:
Aici se initializeaza variabila "c":
c = b*4
c = 3*4
c = 12

- pasul 5:
If este o conditie si se verifica daca este indeplinita conditia. In cazul tau
conditia este:
c > 10
La tine "c" = 12 deci mai mare decat 10 si conditia este indeplinita.
Cand se indeplineste conditia se executa liniile din interiorul acoladelor IF-ului:

- pasul 6:
c = 12 - 10
c = 2

- pasul 7:
Se returneaza c * (60 / a);
Adica: 2*(60/30) = 2*2 = 4

Ce trebuie sa ai in vedere este tipul functiei. In cazul tau functai este INT:
int Func1(void).
Adica ea returneaza unb numar intreg. Daca nu ai RETURN la final iti da
compilatorul eroare.

Functiile care nu returneaza nimic sunt VOID:


void Func1()
Ele fac ceva in interior fara sa mai fie nevoie sa dai RETURN.

-----------------------------------------------------------------
11.

int x = 1, y = 2; - pasul 1
if (x == y) - pasul 2
y = x +10; - pasul 3
x = y + 8; - pasul 4
x++; - pasul 5
- pasul 1:
Aici este la fel ca mai sus. Luam linie cu linie de sus in jos:
x = 1
y = 2

- pasul 2
Apoi se verifica daca x este egal cu y.
Atentie mare:
Cand pui "x==y" verifici ca x este egal cu y.
Daca pui "x=y" pe x il faci egal cu y, adica ii dai valoarea lui

- pasul 3
x nu este egal cu y deci nu se executa urmatoarea linie:
y = x + 10;
Deci y ramane tot cu valoarea initiala 2

- pasul 4
x = y + 8;
x = 2+8 = 10

- pasul 4
x++ inseamna de fapt x = x+1. Il incrementeaza
Deci:
x = 11

Daca observi aici la IF nu ai acolade ca la problema 10.


Daca pui:

if(a == 5)
{
bla bla 1 ---- asta NU se executa
bla bla 2 ---- asta NU se executa
bla bla 3 ---- asta NU se executa
}

Daca a nu este egal cu 5 nu se mai executa nimic din acoloada.

Dar daca ai asa, fara acolada, nu se mai executa doar prima instructiune care
urmeaza dupa IF, adica bla bla 1:
if(a == 5)
bla bla 1 ---- asta NU se executa
bla bla 2 ---- asta se executa
bla bla 3 ---- asta se executa

Practic compilatorul pune automat acolade doar la prima instructiune de dupa IF si


el o considera asa:
if(a == 5)
{
bla bla 1 ---- asta NU se executa
}
bla bla 2 ---- asta se executa
bla bla 3 ---- asta se executa

-----------------------------------------------------------------
12.
for (x=0; x<5; x++);
printf(“x=%d”, x);

Aici gasesti explicat foarte bine cum functioneaza instructiunea FOR.


https://www.tutorialspoint.com/cplusplus/cpp_for_loop.htm

Rezultatul o sa fie
x=1
x=2
x=3
x=4

Asta este o instructiune FOR.

- pasul 1:
x = 0

- pasul 2:
verifica daca x este mai mic decat 5. da, este 0

- pasul 3:
afiseaza valoarea lui x

- pasul 4:
x++ adica x = 1

- pasul 5:
x = 1

- pasul 6:
verifica daca x este mai mic decat 5. da, este 1

- pasul 7:
afiseaza valoarea lui x

- pasul 8:
x++ adica x = 2

si se continua tot asa pana cand x se face 5 si nu se indeplineste conditia de x<5.

-----------------------------------------------------------------
13.
enum actor{
SeanPenn=1,
AlPacino,
KevinSpacey,
EdNorton
};

Enum asta practic iti face o enumeratie. Mereu o sa pui tu doar prima valoare,
restul stie el sa le completeze automat.
Adica programul tau devine cam asa:

enum actor{
SeanPenn = 1,
AlPacino = 2,
KevinSpacey = 3,
EdNorton = 4
};
Aici "a" este o variabila de tip enum actor, pe care l-ai definit tu mai sus.
Deci a ia valoarea 4.
In cazul tau 4 o sa fie "EdNorton".

Instructiunea switch-case iti verifica conditia si te duce la cazul corect.


In cazul tau "a" este 4 deci te va arunca in instructiunea 4, care conform
enumeratiei este "EdNorton".
Dupa cum observi mai jos, pasul 3 o sa fie direct cazul "EdNorton", sare peste
celelalte.
Apoi va afisa "EN".

enum actor a=4; - pasul 1


switch(a){ - pasul 2
case SeanPenn: printf("SP");
break;

case AlPacino: printf("AP");


break;

case KevinSpacey: printf("KS");


break;

case EdNorton: printf("EN"); - pasul 3


break;
}
}

-----------------------------------------------------------------
14.

char are 1 octet


short are 2 octet
float, int are 4 octeti
double are 8 octeti

a. struct s1{int x; int y;};


Aici aloca x si y adica:
2 de int = 8 octeti

b. char m1[2][3];
Aici se face o matrice de 2 linii si 3 coloane:

X1 X2 X3
X4 X5 X6
X7 X8 X9

Adica 9 elemente char care au un octet. In total 9 octeti

c. char c1[10];
Aici se face un vector de 9 elemente

X1 X2 X3 X4 X5 X6 X7 X8 X9

Adica 9 elemente de tip char adica tot 9 octeti

d. union un1{int u; int v;};


La union se aloca memorie pentru elementul cel mai mare.
Tu ai 2 elemente int. Adica se aloca memorie pentru int deci 4 octeti.

Raspunsul este varianta d, cea mai putina memorie o ocupa varianta d.

Daca aveai asa:


union un1{int u; char v;};
int are 4 octeti si char are 2. Se aloca pentru cel mai mare adica 4 octeti.

Daca aveai asa:


union un1{double u; char v;};
double are 8 octeti si char are 2. Se aloca pentru cel mai mare adica 8 octeti.