GiwkLgXL

1#include<stdio.h>
2#include<stdlib.h>
3#include<time.h>
4#pragma warning(disable:4996)
5
6int main()
7{
8
9	int op, i, n = 0, cate, corect = 0, var, foste[32], nerep;
10
11	for (cate = 1; cate <= 30; cate++)
12	{
13		srand(time(NULL));
14		op = rand() % (93) + 0;
15		do {
16			nerep = 0;
17			for (i = 0; i <= 29; i++)
18			{
19				if (op == foste[i])
20				{
21					srand(time(NULL));
22					op = rand() % (93) + 0;
23					nerep = 1;
24					break;
25				}
26			}
27		} while (nerep);
28		foste[n] = op;
29		n++;
30		printf("\nIntrebarea %d", cate);
31		switch (op) {
32		case 1:
33			printf("\nUn obiect este :\n1). o instanţiere a unei clase;    \n2)o abstractizare a unei clase;\n3)o structură a clasei.\n");
34			scanf("%d", &var);
35			if (var == 1)
36			{
37				printf("\nCorect");
38				corect++;
39			}
40			else
41				printf("\nIncorect 1");
42			break;
43		case 2:
44			printf("\n.O funcţie friend :\n1)poate fi declarată static;\n2)	b. nu poate fi declarată static sau extern;\n3)	c. poate fi declarată static dacă clasa prietenă nu are moştenitori..\n");
45			scanf("%d", &var);
46			if (var == 2)
47			{
48				printf("\nCorect");
49				corect++;
50			}
51			else
52				printf("\nIncorect 2");
53			break;
54		case 3:
55			printf("\n3.Utilizarea funcţiilor inline este recomandată pentru :\n1)	a. funcţii recursive;\n2)	b. funcţii optimale;\n3)p	c. funcţii scurte..\n");
56			scanf("%d", &var);
57			if (var == 3)
58			{
59				printf("\nCorect");
60				corect++;
61			}
62			else
63				printf("\nIncorect 3");
64			break;
65		case 4:
66			printf("\n4.În cadrul unei clase, declararea unei variabile static :\n1)	a. alocă o singură dată memorie;\n2)	b. alocă memorie la fiecare creeare a unui obiect de tipul clasei;\n3)	c. nu alocă memorie pentru aceasta.\n");
67			scanf("%d", &var);
68			if (var == 3)
69			{
70				printf("\nCorect");
71				corect++;
72			}
73			else
74				printf("\nIncorect 3");
75			break;
76		case 5:
77			printf("\n5.În fragmentul de mai jos este eronată linia-sursă nr.:class stiva{			//1\nint stiv[size];		//2\n	public:				//3\n	int virf_stiva;		//4\nvoid init();		//5\nvoid pune(int);		//6\nint scoate();		//7\n};				//8\n...\nmain()				//9\n{				//10\nstiva st1, st2;			//11\nst1.pune(44);			//12\nst2.pune(122);			//13\n			st1.virf_stiva = 11;		//14\n			cout << st1.scoate() << ”\n”;		//15\n	cout << st2.scoate() << ”\n”;		//16\n			return 0;				//17\n		}				//18\n\n1)a)	6,13\n2)b)	14\n3)c)	Nici o linie\n");
78			scanf("%d", &var);
79			if (var == 3)
80			{
81				printf("\nCorect");
82				corect++;
83			}
84			else
85				printf("\nIncorect 3");
86			break;
87		case 6:
88			printf("\n.Dacă se pasează un obiect către o funcţie, constructorul :\n1)	a. va fi apelat întotdeaunaş\n2)	b. va fi apelat pentru anumite tipuri de funcţii;\n3)	c. nu este executat.\n");
89			scanf("%d", &var);
90			if (var == 3)
91			{
92				printf("\nCorect");
93				corect++;
94			}
95			else
96				printf("\nIncorect 3");
97			break;
98		case 7:
99			printf("\nO variabilă membră a unei clase poate fi declarată astfel :\n1)	a. de orice tip;\n2)	b. nu poate fi declarată auto, extern sau register;\n3)c. poate fi doar char, integer sau float..\n");
100			scanf("%d", &var);
101			if (var == 2)
102			{
103				printf("\nCorect");
104				corect++;
105			}
106			else
107				printf("\nIncorect 2");
108			break;
109		case 8:
110			printf("\nCe se întâmplă la compilarea următorului program?\n...\n				class cl {\n				int i;\n				public:\n					cl(int j) { i = j; }\n					int ret_i() { return i; }\n			};\...\n				main()\n			{ \n		cl a[5];\n				...			\n}\n			\n1). Se semnalează eroare de compilare la declararea matricii de obiecte;\n2)Programul este corect;\n3)Se semnalează warning (atenţionare) la constructorul clasei.\n");
111			scanf("%d", &var);
112			if (var == 1)
113			{
114				printf("\nCorect");
115				corect++;
116			}
117			else
118				printf("\nIncorect 1");
119			break;
120		case 9:
121			printf("\nO clasă derivată are acces:\n1)	a. la propriii membri şi la toţi membrii clasei de bază;\n2)	b. la funcţiile sale membre şi la variabilele membre ale clasei de bază;\n3)	c. la propriii membri şi la membrii publici ai clasei de bază.\n");
122			scanf("%d", &var);
123			if (var == 3)
124			{
125				printf("\nCorect");
126				corect++;
127			}
128			else
129				printf("\nIncorect 3");
130			break;
131		case 10:
132			printf("\nCare este sintaxa corectă la iniţializare pentru clasa următoare?\nclass cl {\n			int i, j\npublic:\ncl(int k, int l) { i = k; j = l; }\n					int ret_i() { return i; }\n					int ret_j() { return j; }\n			};				\n1)a.cl ob[3] = (1, 2), \n				(3, 4), \n				(5, 6);\n	\n2). cl ob[3]={(1,2),(3,4),(5,6)};\n3). cl ob[3]= { cl(1,2),\n cl(3, 4),\n cl(5, 6)\n};\n");
133			scanf("%d", &var);
134			if (var == 3)
135			{
136				printf("\nCorect");
137				corect++;
138			}
139			else
140				printf("\nIncorect 3");
141			break;
142		case 11:
143			printf("\nCare linie din programul de mai jos este eronată ?\nclass baza {					//1\nint i;					//2\npublic:						//3\nvoid set_i(int val) { i = val; }		//4\n					int ret_i() { return i; }			//5\n			};						//6\nclass derivat::public baza {			//7\nint j;					//8\npublic:						//9\nvoid set_j(int val) { j = val; }		//10\nint ret_j() { return j; }			//11\n};						//12\n			...\nmain()						//13\n{						//14\n				baza *b;					//15\n				derivat d;				//16\n				b = &d;					//17\nb->set_i(5);				//18\n				b->ret_i();				//19\n				b->set_j(55);				//20\n				return 0;					//21\n			}						//22\n\n1)a)	19\n2)b)	17\n3)c)	20\n");
144			scanf("%d", &var);
145			if (var == 3)
146			{
147				printf("\nCorect");
148				corect++;
149			}
150			else
151				printf("\nIncorect 3");
152			break;
153		case 12:
154			printf("\nÎn programul următor, se va semnala eroare. De ce?\n				class baza {\n								protected:	int i, j;\n				public:\n					void set_ij(int a, int b) { i = a;j = b; }\n					void arata_ij() { cout << i << ” ” << j << ” ”; }\n			};\n			class derivat : protected baza {\n									int k;\n			public:\n				void set_k(int a, int b) { set_ij(a, b); k = i*j; }\n				void arata_ijk() { cout << k << ””;arata_ij(); }\n			};\n			...\n				main() {\n				derivat obd;	\n					obd.set_ij(1, 2);	\n				obd.set_k(3);	\n					obd.arata_ijk();	\n					return 0;\n			}\n			\n1). În definirea funcţiei set_k nu poate apare apelul la set_ij().\n2). i şi j trebuie declarate public în clasa de bază;\n3). set_ij nu poate fi apelat asociat obiectului obd        deoarece 		funcţia respectivă este membră protejată pentru clasa derivată\n");
155			scanf("%d", &var);
156			if (var == 3)
157			{
158				printf("\nCorect");
159				corect++;
160			}
161			else
162				printf("\nIncorect 3");
163			break;
164		case 13:
165			printf("\n13.Constructorul clasei derivate :\n1)	a. trebuie în general să declare atât parametrii proprii de apel cât şi parametrii de apel ai clasei de bază;\n2)	b. nu trebuie să declare parametrii constructorului clasei de bază;\n3)	c. nu are voie să conţină declaraţii ale parametrilor de apel ai clasei de bază.\n");
166			scanf("%d", &var);
167			if (var == 1)
168			{
169				printf("\nCorect");
170				corect++;
171			}
172			else
173				printf("\nIncorect 1");
174			break;
175		case 14:
176			printf("\n.Funcţiilor friend :\n1)	a. nu le sunt pasaţi pointeri this;\n2)	b. le sunt pasaţi pointeri this;\n3)	c. le sunt pasaţi pointeri this de tip special.\n");
177			scanf("%d", &var);
178			if (var == 1)
179			{
180				printf("\nCorect");
181				corect++;
182			}
183			else
184				printf("\nIncorect 1");
185			break;
186
187		case 15:
188			printf("\nInstrucţia marcată cu „S” este :\n				class clasa_ex {\n				int i, j;\n				public:\n					clasa_ex(int v_init1, int v_init2) { i = v_init1; j = v_init2; }\n					...\n		};\n			...\n				main() {\n				clasa_ex exemplu(5, 55);		//”S”\n				...		\n			return 0;	\n					}		\n");
189
190			printf("\n1)a.incorectă;\n");
191			printf("\n2)b.corectă;\n");
192			printf("\n3)c.incorectă în cele mai multe contexte;\n");
193			scanf("%d", &var);
194			if (var == 2)
195			{
196				printf("\nCorect");
197				corect++;
198			}
199			else
200				printf("\nIncorect 2");
201			break;
202		case 16:
203			printf("\n16.Funcţiile virtuale:");
204			printf("\n1)	a. pot fi membri statici ai unei clase\n");
205			printf("\n2)	b. nu pot fi membri statici ai unei clase\n");
206			printf("\n3)	c. pot fi membri statici doar într-o clasă derivată şi dacă în clasa de bază nu există nici o definire a funcţiei.\n");
207			scanf("%d", &var);
208			if (var == 2)
209			{
210				printf("\nCorect");
211				corect++;
212			}
213			else
214				printf("\nIncorect 2");
215			break;
216		case 17:
217			printf("\n17.Clasele abstracte sunt :");
218			printf("\n1)	a. clasele fără variabile membre;\n");
219			printf("\n2)	b. clasele care nu corespund necesităţilor de modelare ale unei entităţi fizice (reale)\n");
220			printf("\n3)	c. clasele care conţin cel puţin o functie virtuală pură.\n");
221			scanf("%d", &var);
222			if (var == 3)
223			{
224				printf("\nCorect");
225				corect++;
226			}
227			else
228				printf("\nIncorect 3");
229			break;
230		case 18:
231			printf("\n.Operatorul *  din exemplul de mai jos este corect supraîncărcat?\n				class exemplu {					//1\n				int a, b;					//2\n				public:						//3\n				exemplu() {}				//4\n					exemplu(int i, int j) { a = i; b = j; }		//5\n					void arata() { cout << i << ”” << j << ”\n | ; }	//6\n					exemplu operator* (exemplu ex);		//7\n			};						//8\n			exemplu exemplu::operator* (exemplu ex)		//9\n{						//10\n				exemplu tmp;		//11\n					tmp.a = ex.a*a;		//12\n				temp.b = ex.b*b;		//13\n	return ex;	//14			\n			}				//15\n			");
232			printf("\n1)a. da\n");
233			printf("\n2)	b. Nu, greşeala e la linia 14, trebuie return tmp;\n");
234			printf("\n3)c. Nu, greşeala e la liniile 7 şi 9, funcţia trebuie să fie de tipul void.		\n");
235			scanf("%d", &var);
236			if (var == 2)
237			{
238				printf("\nCorect");
239				corect++;
240			}
241			else
242				printf("\nIncorect 2");
243			break;
244		case 20:
245			printf("\n19.Ce conţine variabila de stare (state) din clasa ios?");
246			printf("\n1)       a. un număr întreg care semnifică numărul de octeţi transmis prin stream la un moment dat;\n");
247			printf("\n2)       b. biţi individuali care specifică modul de desfăşurare a unei operaţii de intrare-ieşire, 	fiecare bit reprezentând câte o eroare posibilă;\n");
248			printf("\n3)       c. biţi individuali care specifică alinierea, formatul de reprezentare, afişare sau nu a bazei, a 		punctului zecimal, forma de afişare (punct fix/forma cu exponent) etc.\n");
249			scanf("%d", &var);
250			if (var == 2)
251			{
252				printf("\nCorect");
253				corect++;
254			}
255			else
256				printf("\nIncorect 2");
257			break;
258		case 21:
259			printf("\n20.Un manipulator este :");
260			printf("\n1)	a. un operator care modelează un stream şi primeşte ca parametru şi întoarce ca rezultat  adresa stream-ului asupra căruia acţionează;");
261			printf("\n2)	b. o instrucţiune de modificare şi conversie a unor valori de intrare sau de ieşire;");
262			printf("\n3)	c. un operator binar care specifică sensul fluxului şi dispozitivul cu care lucrează.\n");
263			scanf("%d", &var);
264			if (var == 1)
265			{
266				printf("\nCorect");
267				corect++;
268			}
269			else
270				printf("\nIncorect 1");
271			break;
272		case 22:
273			printf("\n21. Care sunt funcţiile API care alcătuiesc o buclă de mesaje?");
274			printf("\n1)	a. SendMessage, GetMessage, DispatchMessage");
275			printf("\n2)	b. DispatchMessage,  PutMessage, CallMessage");
276			printf("\n3)	c. GetMessage, TranslateMessage, DispatchMessage\n");
277			scanf("%d", &var);
278			if (var == 3)
279			{
280				printf("\nCorect");
281				corect++;
282			}
283			else
284				printf("\nIncorect 3");
285			break;
286		case 23:
287			printf("\n22. O interfaţă MDI este :");
288			printf("\n1)	a. o interfaţă având posibilitatea lucrului cu fişiere baze de date");
289			printf("\n2)	b. o interfaţă ce permite lucrul cu mai multe dispozitive fizice (Multi-Device Interface)");
290			printf("\n3)	c. o interfaţă orientată-document ce permite afişarea şi prelucrarea simultană a mai multor fişiere, prin intermediul unor ferestre diferite.\n");
291			scanf("%d", &var);
292			if (var == 3)
293			{
294				printf("\nCorect");
295				corect++;
296			}
297			else
298				printf("\nIncorect 3");
299			break;
300		case 24:
301			printf("\n23. Ce oferă clasa Cdocument?");
302			printf("\n1)	a. facilitatea de a deschide un fişier şi de a afişa datele conţinute");
303			printf("\n2)	b. funcţionalitatea de bază pentru colecţii de date pe care utilizatorul le poate accesa sau salva cu File Open sau File Save");
304			printf("\n3)	c. un editor de documente\n");
305			scanf("%d", &var);
306			if (var == 2)
307			{
308				printf("\nCorect");
309				corect++;
310			}
311			else
312				printf("\nIncorect 2");
313			break;
314		case 25:
315			printf("\n24. Utilizatorul interacţionează cu un document prin intermediul:");
316			printf("\n1)	a. unui control Cedit");
317			printf("\n2)	b. unui obiect de tip Cview ascoiat cu acesta");
318			printf("\n3)	c. unei clase Cwind0\n");
319			scanf("%d", &var);
320			if (var == 2)
321			{
322				printf("\nCorect");
323				corect++;
324			}
325			else
326				printf("\nIncorect 2");
327			break;
328		case 26:
329			printf("\n25. Incărcătorul de clase (class loader) serveşte pentru:");
330			printf("\n1)	a. verificarea corectitudinii sintaxei unei clase");
331			printf("\n2)	b. verificarea codului-octet");
332			printf("\n3)	c. incărcarea unei clase de către o subclasă a sa\n");
333			scanf("%d", &var);
334			if (var == 2)
335			{
336				printf("\nCorect");
337				corect++;
338			}
339			else
340				printf("\nIncorect 2");
341			break;
342		case 27:
343			printf("\n26. Ce sunt variabilele instanţă?");
344			printf("\n1)	a. variabilele membre de tip public");
345			printf("\n2)	b. variabilele oarecare");
346			printf("\n3)	c. variabilele membre ale unei clase, care nu sunt de tip static\n");
347			scanf("%d", &var);
348			if (var == 3)
349			{
350				printf("\nCorect");
351				corect++;
352			}
353			else
354				printf("\nIncorect 3");
355			break;
356		case 28:
357			printf("\n27. Ce inseamnă /**   */?");
358			printf("\n1)	a. sintaxă eronată");
359			printf("\n2)	b. comentarii pe un rând");
360			printf("\n3)	c. comentarii pe mai multe linii, care sunt extrase automat din codul-sursă de către generatorul de documentaţie\n");
361			scanf("%d", &var);
362			if (var == 3)
363			{
364				printf("\nCorect");
365				corect++;
366			}
367			else
368				printf("\nIncorect 3");
369			break;
370		case 29:
371			printf("\n28. Care este valoarea implicită a tipului referinţă?");
372			printf("\n1)	a. valoarea null care indică o referinţă încă neprecizată");
373			printf("\n2)	b. valoarea False");
374			printf("\n3)	c. valoarea 0(zero)\n");
375			scanf("%d", &var);
376			if (var == 1)
377			{
378				printf("\nCorect");
379				corect++;
380			}
381			else
382				printf("\nIncorect 1");
383			break;
384		case 30:
385			printf("\n29. Instrucţiunea break produce:");
386			printf("\n1)	a. intreruperea execuţiei programului până când utilizatorul apasă Enter");
387			printf("\n2)	b. „scurtcircuitarea” unei bucle (for,do,while) – adică salt peste instrucţiunile de până la sfârşitul buclei");
388			printf("\n3)	c. intreruprea unei bucle (for,do,while) sau a unui bloc switch\n");
389			scanf("%d", &var);
390			if (var == 3)
391			{
392				printf("\nCorect");
393				corect++;
394			}
395			else
396				printf("\nIncorect 3 ");
397			break;
398		case 31:
399			printf("\n. Care va fi efectul secvenţei următoare_\n do{ \n		car_citit = (char)System.in.read();   \n			rel(car_citit);			\n		}					\n			while (car_citit != ’T’);\n				");
400			printf("\n1)a.se prelucrează toate caracterele tastate până   când se apasă T; acesta nu va fi prelucrat");
401			printf("\n2)b.se ignoră toate caracterele diferite de T");
402			printf("\n3)c.se prelucrează toate caracterele testate până      se apasă T; acesta va fi de asemenea prel.\n");
403			scanf("%d", &var);
404			if (var == 3)
405			{
406				printf("\nCorect");
407				corect++;
408			}
409			else
410				printf("\nIncorect 3");
411			break;
412		case 32:
413			printf("\n31. Instanţierea unui obiect se face prin:");
414			printf("\n1)	a. declararea obiectului");
415			printf("\n2)	b. operatorul new");
416			printf("\n3)	c. declarare şi atribuire\n");
417			scanf("%d", &var);
418			if (var == 3)
419			{
420				printf("\nCorect");
421				corect++;
422			}
423			else
424				printf("\nIncorect 3");
425			break;
426		case 33:
427			printf("\n. În fragmentul următor de program sintaxa liniei marcate este:\n				public class Biblio {\n				private nr_carti;\n				public Biblio(int nr_init)		\n				{ nr_carti = nr_init; }\n					public int CiteCarti()		\n				{ return nr_carti; }\n					…\n			}\n			…\n			Int carti_in_biblio = new Biblio(100).CateCarti();   //marcaj\n			");
428			printf("\n1)a.validă ");
429			printf("\n2)o/o	b.nu este validă ");
430			printf("\n3)c.ambiguă\n");
431			scanf("%d", &var);
432			if (var == 1)
433			{
434				printf("\nCorect");
435				corect++;
436			}
437			else
438				printf("\nIncorect 1");
439
440			break;
441		case 34:
442			printf("\n33. Cum putem afişa ceva pe ecran în cadrul unei miniaplicaţii?");
443			printf("\n1)	a. scriem în metoda init() secvenţa \npublic void init(Thread th){\n th.drawstring(“textul de afisat”);\n}\n");
444			printf("\n2)	b. scriem în metoda repaint() secvenţa System.out.println(”textul de afişat”);");
445			printf("\n3)c. suprascriem metoda paint() astfel:\n  public void paint(Graphics gr){\n gr.drawstring(“textul de afisat”);\n } \n ");
446			scanf("%d", &var);
447			if (var == 3)
448			{
449				printf("\nCorect");
450				corect++;
451			}
452			else
453				printf("\nIncorect 3");
454			break;
455		case 35:
456			printf("\n34. Activităţile aferente precizării structurii statice în cadrul metodei Civello şi Mitchell au ca scop:");
457			printf("\n1)	a. precizarea structurii programului(module, funcţii, fişiere, clase, obiecte)");
458			printf("\n2)	b. definirea claselor şi a relaţiilor dintre ele(comunicaţia între clase, clasificări, atribuiri)");
459			printf("\n3)	c. definirea ierarhiilor de clase(moştenirea, polimorfism, supraîncărcarea, constructori, destructori).");
460			scanf("%d", &var);
461			if (var == 2)
462			{
463				printf("\nCorect");
464				corect++;
465			}
466			else
467				printf("\nIncorect 2");
468			break;
469		case 36:
470			printf("\n35. Pentru un produs-program, pot fi distinse următoarele nivele generale de abstractizare:");
471			printf("\n1)	a. variabile de instanţă, instanţierea claselor generice, moştenire, mesaje");
472			printf("\n2)	b. domeniul problemei,utilizator, gestiunea fişierelor, gestiunea proceselor, structuri de date fundamentale, interfaţa cu perifericele");
473			printf("\n3)	c. nivelul logic, nivelul comunicaţiei, nivelul driver, nivelul fizic, nivelul aplicaţiei, nivelul interfeţei utilizator\n");
474			scanf("%d", &var);
475			if (var == 2)
476			{
477				printf("\nCorect");
478				corect++;
479			}
480			else
481				printf("\nIncorect 2");
482			break;
483		case 37:
484			printf("\n36.Java permite realizarea programarii concurente prin:");
485			printf("\n1) 	 a)...  ");
486			printf("\n2) b)... ");
487			printf("\n3) c)folosirea firelor de executie si sincronizarea metodelor\n");
488			scanf("%d", &var);
489			if (var == 3)
490			{
491				printf("\nCorect");
492				corect++;
493			}
494			else
495				printf("\nIncorect 3");
496			break;
497		case 38:
498			printf("\n37.principalele biblioteci de clase Java sunt orientate pe ");
499			printf("\n1) a)pe GUI, imagini si audio, lucrul in retea ");
500			printf("\n2) b)TCP/IP, FTP  ");
501			printf("\n3) 	 c)interfata cu utilizatorul, interfata de retea,interfata cu  baza de date\n");
502			scanf("%d", &var);
503			if (var == 1)
504			{
505				printf("\nCorect");
506				corect++;
507			}
508			else
509				printf("\nIncorect 1");
510			break;
511		case 39:
512			printf("\n38.secventa de program Java de mai jos\n	public class Apartament {   		//1\n				private:    				//2\n					int nr_cam;  			 //3\n					int supraf; 			  //4\n				public:   				 //\n					Apartament(int nrc, int sup)             //6\n{\n						nr_cam = nrc; supraf = sup;\n					}        //7\n					...\n			};      					//8\n	");
513			printf("\n1)  a)este corecta");
514			printf("\n2)  b)este eronata, trebuie private in liniile 3 si 4, public in linia 6, toate fara : si in linia 8 nu trebuie ;");
515			printf("\n3)  c)...\n");
516			scanf("%d", &var);
517			if (var == 2)
518			{
519				printf("\nCorect");
520				corect++;
521			}
522			else
523				printf("\nIncorect 2");
524			break;
525		case 40:
526			printf("\n39.ce semnifica sintaxa de la linia marcata ?\n				public class Biblioteca {\n				public Biblioteca() { this(0); }   //marcaj\n				public Biblioteca(int nrc\n				{ \n					nr_crt = private nr_crt;    //aici am observat ca lipseste tipul campului !? \n					...\n				}\n				");
527			printf("\n1)  a)este un constructor care pune pe zero obiectul curent");
528			printf("\n2) 	  b)este o metoda speciala care genereaza o referinta la obiectul  curent ");
529			printf("\n3)  	  c) este un constructor care initializeaza cu o valoare  redefinita (aici , zero) variabila instanta, prin apelul celuilalt  constructor, inlocuind astfel conventia cu argumente implicite,  care nu este disponibila in Java.\n");
530			scanf("%d", &var);
531			if (var == 3)
532			{
533				printf("\nCorect");
534				corect++;
535			}
536			else
537				printf("\nIncorect 3");
538			break;
539		case 41:
540			printf("\n40.* Ce sunt variabilele de tip instanta in Java? ");
541			printf("\n1) a)variabile membre de tip public ");
542			printf("\n2 	 b)variabile oarecare  ");
543			printf("\n3) c)variabilele membre ale unei clase, care nu sunt de tip static \n");
544			scanf("%d", &var);
545			if (var == 3)
546			{
547				printf("\nCorect");
548				corect++;
549			}
550			else
551				printf("\nIncorect 3");
552			break;
553		case 42:
554			printf("\n41.Graphics este in Java :");
555			printf("\n1)a)o variabila membra a java.applet.Applet care permite apelarea  operatiilor de intrare/iesire  ");
556			printf("\n2)b)un tip predefinit care contine mai multe metode pentru  desenarea imaginilor si scrierea textului pe ecran  ");
557			printf("\n3)c)denumirea engleza a aspectelor grafice ale miniaplicatiilor  Java\n");
558			scanf("%d", &var);
559			if (var == 2)
560			{
561				printf("\nCorect");
562				corect++;
563			}
564			else
565				printf("\nIncorect 2");
566			break;
567		case 43:
568			printf("\n42.Prin mostenire intelegem:");
569			printf("\n1)a) separarea aspectelor externe ale unui obiect,accesibile altor obiecte,de cele interne.");
570			printf("\n2)b) ca aceeasi metoda poate avea comportament diferit in clase diferite.");
571			printf("\n3)c) transmiterea atributelor si operatiilor de-a lungul claselor bazate pe o relatie ierarhica.\n");
572			scanf("%d", &var);
573			if (var == 3)
574			{
575				printf("\nCorect");
576				corect++;
577			}
578			else
579				printf("\nIncorect 3");
580			break;
581		case 44:
582			printf("\n43.In lipsa specificatorilor „public” si „private” toti membrii unei clase vor fi implicit:");
583			printf("\n1)	a) privati");
584			printf("\n2)	b) compilatorul va semnala eroare");
585			printf("\n3)	c) publici\n");
586			scanf("%d", &var);
587			if (var == 1)
588			{
589				printf("\nCorect");
590				corect++;
591			}
592			else
593				printf("\nIncorect 1");
594			break;
595		case 45:
596			printf("\n44.O functie virtuala:");
597			printf("\n1)	a) defineste o metoda care nu poate fi apelata din clasa derivata chiar daca este publica.");
598			printf("\n2)	b) defineste o clasa generala de actiuni iar redefinirea ei introduce o metoda specifica.");
599			printf("\n3)	c) defineste o metoda specifica iar redefinirea ei introduce o clasa generala de actiuni.\n");
600			scanf("%d", &var);
601			if (var == 2)
602			{
603				printf("\nCorect");
604				corect++;
605			}
606			else
607				printf("\nIncorect 2");
608			break;
609		case 46:
610			printf("\n45. Fie urmatoarea secventa de program:\n				Class A\n			{ \n				...\n				Public:  int adunare(int x,int y)\n			{ \n				...\n			}\n			};\n			Class B : public A\n			{ \n				...\n				Public:  float adunare(float x,float y)\n			{ \n				...\n			}\n			};\n			Daca avem un obiect : B ob(de tipul lui B) atunci B.adunare(3, 4) va apela : \n			");
611			printf("\n1)a)	Va genera eroare deoarece B este o clasa si nu un obiect");
612			printf("\n2)b)	 Functia adunare din clasa B");
613			printf("\n3)c)	 Functia adunare din clasa A\n");
614			scanf("%d", &var);
615			if (var == 1)
616			{
617				printf("\nCorect");
618				corect++;
619			}
620			else
621				printf("\nIncorect 1 ");
622			break;
623		case 47:
624			printf("\n46. Programul urmator are ca efect:\n #include<iostream.h>\n				Class exemplu_static{ \n				Static int a;	//aici e o variabila membra de tip static\n			Int b;		// aceasta nu e de tip static\n		Public:\n			Void seteaza(int i,int j) { a = i; b = j; }\n			Void arata();\n			};\n			Int exemplu_static::a; 	// iata si definirea globala\n									// pentru variabila de tip static\n			Void exemplu_static::arata()\n			{ \n				Cout << ”acesta este a static:”  << a;\n				Cout << ”acesta este b ne - static: „ << b;\n				Cout << ” ”;\n			}\n			Main()\n			{ \n				Exemplu_static ob1, ob2;	//doua obiecte de tipul clasei\nOb1.seteaza(1, 2);\n				Ob1.arata();\n				Ob2.seteaza(3, 4);\n				Ob2.arata();\n				Ob1.arata();\nReturn 0;\n}\nAfisarea urmatoarelor texte : \n");
625			printf("\n1)a)	Acesta este a static: 1   \n         				Acesta este b ne - static: 2   \n				Acesta este a static: 1	       \n				Acesta este b ne - static : 4	   \n				Acesta este a static: 1	          \n				Acesta este b ne - static : 2	   \n	");
626			printf("\n2)b)	Acesta este a static: 1\n				Acesta este b ne - static: 2\n				Acesta este a static: 3\n				Acesta este b ne - static : 4\n				Acesta este a static: 3\n			Acesta este b ne - static : 2\n	");
627			printf("\n3)1              c)  acesta este a static: 1\n				             acesta este b ne - static : 2\n					            acesta este a static: 1\n				            acesta este b ne - static : 4\n			            acesta este a static: 3\n					            acesta este b ne - static : 2\n\n");
628			scanf("%d", &var);
629			if (var == 2)
630			{
631				printf("\nCorect");
632				corect++;
633			}
634			else
635				printf("\nIncorect 2");
636			break;
637		case 48:
638			printf("\n47. Daca avem o clasa student si constructorul acesteia de forma student( char *x,int y); atunci un obiect initializat se va declara:");
639			printf("\n1)	a) student a();");
640			printf("\n2)	b) student a(„Ion”,4);");
641			printf("\n3)	c)  student („Ion”,4);\n");
642			scanf("%d", &var);
643			if (var == 2)
644			{
645				printf("\nCorect");
646				corect++;
647			}
648			else
649				printf("\nIncorect 2");
650			break;
651		case 49:
652			printf("\nAvand secventa de program:\n				Class aaa\n			{ \n				Int x;\n			...\n				Public\n			...\n			};\n			...\n				aaa ob\n			cout << ob.x;\n			");
653			printf("\n1)a)	Secventa este corecta");
654			printf("\n2)b)	Secventa de cod nu este corecta deoarece trebuia scris cout<<x;");
655			printf("\n3)c)	Secventa de cod nu este corecta,deoarece nu avem acces la membrii privati ai unei clase.\n");
656			scanf("%d", &var);
657			if (var == 3)
658			{
659				printf("\nCorect");
660				corect++;
661			}
662			else
663				printf("\nIncorect 3");
664			break;
665		case 50:
666			printf("\n49. Secventa urmatoare de program:\n#include<iostream.h>\n				Class ordine{ \n			Public\nInt cine;\n				Ordine(int);\n				~ordine();\n			} glob_ob1(10), glob_ob2(20); 	// doua obiecte globale\n			ordine::ordine(int valinit)\n			{ \n				Cout << ”Initializare „ << valinit << ” ”;\n				Cine = valinit;\n			}\n			Ordine::~ordine()\n			{ \n				Cout << ”distrugere „ << cine << ” ”;\n			}\n			Main()\n			{ \n				Ordine local_ob1(30);	// obiect local\n				Cout << ”Vedeti ? Aceasta nu e prima linie afisata!”;\n				Ordine local_ob2(40);	//alt obiect local\n				Return 0;\n			}\n			Va determina afisarea urmatoarelor texte \n				");
667			printf("\n1)a)	Initializare 10\n				Initializare 20\n				Initializare 30\n				Initializare 40\n				Vedeti ? Aceasta nu e prima linie afisata!\n				Distrugere 40\n				Distrugere 30\n				Distrugere 20\n				Distrugere 10\n				");
668			printf("\n2)b)	Initializare 10\n				Initializare 20\n				Initializare 30\n				Vedeti ? Aceasta nu e prima linie afisata!\n				Initializare 40\n				Distrugere 40\n				Distrugere 30\n				Distrugere 20\n				Distrugere 10\n				");
669			printf("\n3)c)	Initializare 10\n				Initializare 20\n				Initializare 30\n				Vedeti ? Aceasta nu e prima linie afisata!\n				Initializare 40\n				Distrugere 10\n				Distrugere 20\n				Distrugere 30\n				Distrugere 40\n				\n");
670			scanf("%d", &var);
671			if (var == 2)
672			{
673				printf("\nCorect");
674				corect++;
675			}
676			else
677				printf("\nIncorect 2");
678			break;
679		case 51:
680			printf("\n50. Fie urmatoarea secventa de program:\n				Class A\n			{ \n				...\n				Public: \n			Int functie(int x,int y)\n			{ \n				...\n			}\n			};\n			Class B : public A\n			{ \n				...\n				Public: \n			...\n			};\n			Daca avem un obiect : B ob(de tipul lui B) atunci ob.functie(5, 8) : \n				");
681			printf("\n1)a)	Va apela functia din clasa A deoarece clasa B mosteneste public clasa A");
682			printf("\n2)b)	Va genera eroare deoarece in clasa B nu exista functia adunare.");
683			printf("\n3)c)	Va genera eroare deoarece clasa B nu are acces la functiile membre ale clasei A\n");
684			scanf("%d", &var);
685			if (var == 1)
686			{
687				printf("\nCorect");
688				corect++;
689			}
690			else
691				printf("\nIncorect 1");
692			break;
693		case 52:
694			printf("\n51. O clasa poate avea:");
695			printf("\n1)	a) un singur constructor si un singur destructor.");
696			printf("\n2)	b) mai multi constructori si un singur destructor.");
697			printf("\n3)	c) mai multi constructori si destructori.\n");
698			scanf("%d", &var);
699			if (var == 2)
700			{
701				printf("\nCorect");
702				corect++;
703			}
704			else
705				printf("\nIncorect 2");
706			break;
707		case 53:
708			printf("\n52. Care din urmatoarele afirmatii este falsa?");
709			printf("\n1)	a) constructorul nu poate fi virtual,destructorul poate fi.");
710			printf("\n2)	b) functiile virtuale nu pot fi membri statici ai clasei.");
711			printf("\n3)	c) functiile virtuale pot fi membri friend ai clasei.\n");
712			scanf("%d", &var);
713			if (var == 3)
714			{
715				printf("\nCorect");
716				corect++;
717			}
718			else
719				printf("\nIncorect 3");
720			break;
721		case 54:
722			printf("\n53. Un constructor poate returna:");
723			printf("\n1)	a) numai tipuri de date predefinite in C sau C++.");
724			printf("\n2)	b) nu poate returna o valoare.");
725			printf("\n3)	c) tipuri de date definite de programatori sau tipuri de date predefinite in C sau C++.\n");
726			scanf("%d", &var);
727			if (var == 2)
728			{
729				printf("\nCorect");
730				corect++;
731			}
732			else
733				printf("\nIncorect 2");
734			break;
735		case 55:
736			printf("\n54. Daca o clasa de baza este mostenita private, toti membrii publici ai clasei devin in clasa derivata membri:");
737			printf("\n1)	a) publici");
738			printf("\n2)	b) privati");
739			printf("\n3)	c) protejati\n");
740			scanf("%d", &var);
741			if (var == 2)
742			{
743				printf("\nCorect");
744				corect++;
745			}
746			else
747				printf("\nIncorect 2");
748			break;
749		case 56:
750			printf("\n55. Secventa urmatoare de program:\n #include<iostream.h>			//1\n				Class un_param{				//2\n				Int a;				//3\n		Public:					//4\n			Un_param(int i);			//5\n			Int da_a() { return a; }		//6\n			};					//7\n			Main()					//8\n			{\n				Un_param obiect = 55;		//9   paseaza 55 lui i din constructor si \n				Cout << obiect.da_a();		//10 afiseaza ca sa ne convingem ca asa e\n				Return 0;			//11\n			}					//12\n			Va da eroare de compilare deoarece : \n");
751			printf("\n1)a)	Linia 7 are „;” dupa acolada");
752			printf("\n2)b)	Linia 9 trebuie sa arate corect asa: un_param obiect(55)");
753			printf("\n3)c)	Constructorul nu e definit (trebuia: un_param(int i){a=i;})	\n");
754			scanf("%d", &var);
755			if (var == 3)
756			{
757				printf("\nCorect");
758				corect++;
759			}
760			else
761				printf("\nIncorect 3");
762			break;
763		case 57:
764			printf("\n56. O clasa care contine o functie virtuala se numeste:");
765			printf("\n1)	a) clasa polimorfica");
766			printf("\n2)	b) clasa incapsulata");
767			printf("\n3)	c) clasa virtuala\n");
768			scanf("%d", &var);
769			if (var == 1)
770			{
771				printf("\nCorect");
772				corect++;
773			}
774			else
775				printf("\nIncorect 1");
776			break;
777		case 58:
778			printf("\n. Precizati varianta corecta de creare a unui tablou de obiecte de tipul A. Fie:\n				Class A\n			{ \n			Public: \n				...\n			};\n			A obiect;\n			Pentru a crea un tablou de obiecte trebuie facut : \n			");
779			printf("\n1)a)	Tablou A(10);");
780			printf("\n2)b)	Tablou A[10];");
781			printf("\n3)c)	A tablou[10];\n");
782			scanf("%d", &var);
783			if (var == 3)
784			{
785				printf("\nCorect");
786				corect++;
787			}
788			else
789				printf("\nIncorect 3");
790			break;
791		case 59:
792			printf("\n58. In cadrul unei clase se defineste o variabila membru statica.Atunci:");
793			printf("\n1)a) pentru fiecare instantiere a clasei avem cate o variabila membru statica.");
794			printf("\n2)b) pentru toate instantierile clasei avem o singura variabila membru statica.");
795			printf("\n3)c) o clasa nu poate fi instantiata mai mult decat o data daca avem declarat in cadrul ei o variabila membru statica.\n");
796			scanf("%d", &var);
797			if (var == 2)
798			{
799				printf("\nCorect");
800				corect++;
801			}
802			else
803				printf("\nIncorect 2");
804			break;
805		case 60:
806			printf("\n59. Care este avantajul folosirii clasei Carray?");
807			printf("\n1)	a) poate accesa liste foarte lungi");
808			printf("\n2)	b) permite verificarea domeniului la accesarea unui tablou");
809			printf("\n3)	c) permite ordonarea rapida a unei liste\n");
810			scanf("%d", &var);
811			if (var == 2)
812			{
813				printf("\nCorect");
814				corect++;
815			}
816			else
817				printf("\nIncorect 2");
818			break;
819		case 61:
820			printf("\n60. Ce este biblioteca de tipare standard?");
821			printf("\n1)	a) un set de colectii,algoritmi si functii generale care utilizeaza masiv tiparele pentru functiile si clasele sale.");
822			printf("\n2)	b) un sistem grafic de preincarcare a unei imagini standardizate pentru fisiere bitmap.");
823			printf("\n3)	c) o biblioteca cu tipare de functii matematice standardizate.\n");
824			scanf("%d", &var);
825			if (var == 1)
826			{
827				printf("\nCorect");
828				corect++;
829			}
830			else
831				printf("\nIncorect 1");
832			break;
833		case 62:
834			printf("\n61. Un container serveste pentru:");
835			printf("\n1)	a) stocarea mai multor tablouri de valori");
836			printf("\n2)	b) maparea evenimentelor la obiecte");
837			printf("\n3)	c) stocarea obiectelor\n");
838			scanf("%d", &var);
839			if (var == 3)
840			{
841				printf("\nCorect");
842				corect++;
843			}
844			else
845				printf("\nIncorect 3");
846			break;
847		case 63:
848			printf("\n. In ce ordine se vor afisa numerele de catre programul urmator?\n#include<stdafx.h>\n#include<iostream.h>\n#include<vector>\n#include<algorithm>\n				Using namespace std;\n			Typedef vector<int> vectsort;\n			Int main(int argc, char *argv[])\n			{ \n				Vectsort v;\n				v.push_back(434);\n				v.push_back(356);\n				v.push_back(267);\n				v.push_back(987);\n				sort(v.begin(), v.end());\n				vector<int>::reverse_iterator iter = v.rbegin();\n				while (iter != v.rend())\n				{ \n					Cout << *iter << endl;\n					++iter;\n				}\n				Return 0;\n			}\n");
849			printf("\n1)a)	434,356,267,987");
850			printf("\n2)b)	267,356,434,987");
851			printf("\n3)c)	987,434,356,267\n");
852			scanf("%d", &var);
853			if (var == 3)
854			{
855				printf("\nCorect");
856				corect++;
857			}
858			else
859				printf("\nIncorect 3");
860			break;
861		case 64:
862			printf("\n62. Pentru o colectie de tip harta,mecanismul de regasire a informatiei este:");
863			printf("\n1)	a) fiecarui articol stocat intr-o harta ii este asociata o cheie unica,fiecare cheie este convertita mai intai intr-o valoare codificata (hash value), care este folosita apoi pentru a cauta articolul dorit dintr-o lista.");
864			printf("\n2)b) fiecarui articol stocat intr-o harta ii este asociata o cheie unica,fiecare cheie este convertita mai intai intr-o valoare codificata (hash value), care este folosita apoica indice intr - o matrice unde sunt stocate articolele din colectie				");
865			printf("\n3)d)	exista o harta a memoriei (memory map) unde fiecarui articol ii corespunde un indice unic numit hash index, prin accesarea cu hash index se determina selectia automata a articolului dorit.\n");
866			scanf("%d", &var);
867			if (var == 2)
868			{
869				printf("\nCorect");
870				corect++;
871			}
872			else
873				printf("\nIncorect 2");
874			break;
875		case 65:
876			printf("\n63. Iteratorii se folosesc pentru:");
877			printf("\n1)	a) indicarea evolutiei calculelor in cadrul unor iteratii din algoritmii recursivi");
878			printf("\n2)	b) numararea elementelor dintr-un container");
879			printf("\n3)	c) deplasarea printre articolele stocate intr-un container.\n");
880			scanf("%d", &var);
881			if (var == 3)
882			{
883				printf("\nCorect");
884				corect++;
885			}
886			else
887				printf("\nIncorect 3");
888			break;
889		case 66:
890			printf("\n64. Cum e corect?");
891			printf("\n1)a) \n				template<class T> \n			class CStack \n			{ \n			Public: \n				Cstack(); \n				Virtual ~Cstack(); \n				BOOL IsEmpty()const; \n				T  Pop(); \n				Void Push(const T&item); \n			Private: \n				CStack <T>(const CStack &T) {}; \n				... \n");
892			printf("\n2)b) \n				template<int T> \n			class CStack \n			{ \n			Public \n				Cstack(); \n				Virtual  ~Cstack(); \n				BOOL IsEmpty()const; \n				T  Pop(); \n				Void Push(const T&item); \n			Private: \n				CStack <T>(const CStack &T) {}; \n				... \n					");
893			printf("\n3)c)\n				typedef  template<int T>\n				class CStack\n			{ \n			Public: \n				Cstack();\n				Virtual  ~Cstack();\n				BOOL IsEmpty()const;\n				T  Pop();\n				Void Push(const T&item);\n			Private: \n				CStack <T>(const CStack &T) {};\n				...\n");
894			scanf("%d", &var);
895			if (var == 1)
896			{
897				printf("\nCorect");
898				corect++;
899			}
900			else
901				printf("\nIncorect 1");
902			break;
903		case 67:
904			printf("\n65. Tiparele de programare au avantajul ca permit:");
905			printf("\n1)	a) definire de clase care pot fi usor reutilizate prin mostenire");
906			printf("\n2	b) utilizarea de clase si functii care accepta parametri la folosire");
907			printf("\n3)	c) apeluri simple pentru transferul parametrilor actuali\n");
908			scanf("%d", &var);
909			if (var == 2)
910			{
911				printf("\nCorect");
912				corect++;
913			}
914			else
915				printf("\nIncorect 2");
916			break;
917		case 68:
918			printf("\n	66. In codul sursa de mai jos instructia marcata cu $ este:\n				...\n				Class cladire{ \n			Int camere;\n			Int etaje;\n		Public: \n			Void nr_camere(int);\n			Int cate_camere();\n			Void nr_etaje(int);\n			Int cate_etaje();\n			};\n			Class apartament : public cladire{ \n				Int dormitoare;\n		Public: \n			Void nr_dormitoare(int);\n			Int cate_dormitoare();\n			};\n			...\n				Main()\n			{\n				Apartament ap;\n				Ap.nr_dormitoare(2);\n				Ap.nr_camere(5);		// $\n				...\n");
919			printf("\n1)a)	corecta daca cuvantul-cheie public de la clasa apartament e schimbat in private");
920			printf("\n2)b)	incorecta");
921			printf("\n3)c)	valida\n");
922			scanf("%d", &var);
923			if (var == 3)
924			{
925				printf("\nCorect");
926				corect++;
927			}
928			else
929				printf("\nIncorect 3");
930			break;
931		case 69:
932			printf("\n67. Executabilul generat de un mediu de dezvoltare pentru sisteme incorporate ruleaza:");
933			printf("\n1)	a) pe microcontrollerul incorporat din sistemul gazda (host)");
934			printf("\n2)	b) pe calculatorul pe care ruleaza mediul de dezvoltare");
935			printf("\n3)	c) pe microcontrollerul din sistemul incorporat\n");
936			printf("\n la asta nu e sigur raspunsul\n");
937			scanf("%d", &var);
938			if (var == 3)
939			{
940				printf("\nCorect");
941				corect++;
942			}
943			else
944				printf("\nIncorect 3");
945			break;
946		case 70:
947			printf("\n69. Pentru a implementa arhitectura document-view intr-o aplicatie MFC,pentru partea de document:");
948			printf("\n1)	a) Se deriveaza o clasa din Cdocument pentru fiecare tip de document,se adauga variabile membre pentru a stoca fiecare data document,se implementeaza functii membre pentru citirea si modificarea datelor document si se suprascrie functia membra Cobject::On-Update pentru a actualiza datele de pe disc.");
949			printf("\n2)	b) Se deriveaza o clasa din Cdocument pentru fiecare tip de document,se adauga variabile membre pentru a stoca fiecare data document,se implementeaza functii membre pentru citirea si modificarea datelor document si se suprascrie functia membra Cobject::Serialize in clasa document pentru a scrie si citi date document pe si de pe disc.");
950			printf("\n3)	c) Se deriveaza o clasa din Cdocument pentru fiecare tip de document,se adauga variabile membre pentru a stoca fiecare data document,se implementeaza functia UpdateAllViews pentru actualizarea tuturor vizualizarilor si se suprascrie functia membra Cobject::Serialize in clasa document pentru a scrie si citi date document pe si de pe disc.\n");
951			scanf("%d", &var);
952			if (var == 2)
953			{
954				printf("\nCorect");
955				corect++;
956			}
957			else
958				printf("\nIncorect 2");
959			break;
960		case 71:
961			printf("\n70. Mecanismul de actualizare a tuturor vizualizarilor in cadrul arhitecturii document-view presupune:");
962			printf("\n1)	a) Modificarea documentului prin accesul din cadrul vizualizarii la metoda de modificare a variabilei membre din clasa derivata din CDocument,apelul metodei UpdateAllViews din acea clasa,care trimite notificari catre toate vizualizarile active si suprascrierea metodelor OnDraw (de desenare) din clasele de vizualizare,pentru a implementa actualizarile dorite pe aceste vizualizari.");
963			printf("\n2)	b) Modificarea documentului prin accesul din cadrul vizualizarii la metoda de modificare a variabilei membre din clasa derivata din CDocument,apelul metodei UpdateAllViews din acea clasa,care trimite notificari catre toate vizualizarile active si suprascrierea metodelor OnUpdate din clasele de vizualizare,pentru a implementa actualizarile dorite pe aceste vizualizari.");
964			printf("\n3)	c) Modificarea documentului prin accesul din cadrul vizualizarii la metoda de serializare a variabilei membre din clasa derivata din CDocument,apelul metodei UpdateAllViews din acea clasa,care trimite notificari catre toate vizualizarile active si suprascrierea metodelor OnRedraw (de redesenare) din clasele de vizualizare,pentru a implementa actualizarile dorite pe aceste vizualizari.\n");
965			scanf("%d", &var);
966			if (var == 2)
967			{
968				printf("\nCorect");
969				corect++;
970			}
971			else
972				printf("\nIncorect 2");
973			break;
974		case 72:
975			printf("\n71. Modelarea orientata pe obiecte parcurge urmatoarele etape:");
976			printf("\n1)	a) definirea claselor si a relatiilor dintre ele (comunicatia intre clase,clasificari, atribute)");
977			printf("\n2)	b) analiza a ceea ce face sistemul sa functioneze, examinarea domeniului problemei, utilizarea entitatilor si relatiilor dintre acestea pentru a concepe arhitectura aplicatiei.");
978			printf("\n3)	c) analiza a ceea ce face sistemul, determinarea functiunilor necesare prin descompunerea problemei in altele mai mici, determinarea claselor si a relatiior dintre acestea.\n");
979			scanf("%d", &var);
980			if (var == 2)
981			{
982				printf("\nCorect");
983				corect++;
984			}
985			else
986				printf("\nIncorect 2");
987			break;
988		case 73:
989			printf("\n72. In cadrul modelarii orientate pe obiecte, avem urmtoarele avantaje fata de abordarea structurata:");
990			printf("\n1)	a) este mai bine deoarece programul este vazut ca un model al realitatii, fiind format din obiecte care interactioneaza actiunile intreprinse in program se fac de catre obiecte si cu ajutorul lor.");
991			printf("\n2)	b) entitatile sunt mai stabile decat functiile, intretinerea aplicatiei este mai usoara, componentele de program sunt mai usor reutilizabile si tranzitia de la analiza la proiectare si implementare este naturala.");
992			printf("\n3)	c) etapele de dezvoltare sunt mai coerente deoarece se incepe cu ceea ce face sistemul sa functioneze, apoi se examineaza domeniul problemei,pentru a gasi entitati care au limite( frontiere) fizice sau conceptuale care le separa de restul domeniului si se utilizeaza entitatile si relatiile dintre acestea pentru a concepe arhitectura aplicatiei.\n");
993			scanf("%d", &var);
994			if (var == 2)
995			{
996				printf("\nCorect");
997				corect++;
998			}
999			else
1000				printf("\nIncorect 2");
1001			break;
1002		case 74:
1003			printf("\n73. Analiza orientata pe obiecte este:");
1004			printf("\n1)	a) analiza solutiilor posibile prin inventarea (conceperea) sau alegerea claselor de obiecte pentru domeniul solutiilor si stabilirea relatiilor logice si interactiunilor dintre ele.");
1005			printf("\n2)	b) descoperirea obiectelor esentiale (key objects) la nivelul curent de abstractizare si transferarea responsabilitatilor sistemului catre obiecte.");
1006			printf("\n3)	c) procesul de identificare si definire a claselor (obiectelor) ce apartin domeniului problemei.\n");
1007			scanf("%d", &var);
1008			if (var == 3)
1009			{
1010				printf("\nCorect");
1011				corect++;
1012			}
1013			else
1014				printf("\nIncorect 3");
1015			break;
1016		case 75:
1017			printf("\n74. In UML mesajul este:");
1018			printf("\n1)	a) abstractie a unei unitati de comunicare intre un obiect sursa si un obiect tinta( cel care receptioneaza mesajul)");
1019			printf("\n2)	b) un apel CallAction");
1020			printf("\n3)	c) trimiterea unui semnal de la un obiect sursa la un obiect tinta (cel care receptioneaza mesajul).\n");
1021			scanf("%d", &var);
1022			if (var == 1)
1023			{
1024				printf("\nCorect");
1025				corect++;
1026			}
1027			else
1028				printf("\nIncorect 1");
1029			break;
1030		case 76:
1031			printf("\n75. Relatiile dintre clase si obiecte sunt de tipul:");
1032			printf("\n1)	a) colaborare, extensie, specializare, principiul de susbstitutie al lui Liskov");
1033			printf("\n2)	b) asociere, agregare, compozitie, generalizare, dependenta");
1034			printf("\n3)	c) parte/intreg, catalog, fizic,tip mesaj, compozitie, dependenta,generalizare.\n");
1035			scanf("%d", &var);
1036			if (var == 2)
1037			{
1038				printf("\nCorect");
1039				corect++;
1040			}
1041			else
1042				printf("\nIncorect 2");
1043			break;
1044		case 77:
1045			printf("\n76. Cerintele functionale in UML");
1046			printf("\n1)	a) sunt codificate prin note text");
1047			printf("\n2)	b) sunt reprezentate direct de cazurile de utilizare");
1048			printf("\n3)	c) sunt reprezentate prin diagrame de secventa si prin diagrame de stare. \n");
1049			scanf("%d", &var);
1050			if (var == 3)
1051			{
1052				printf("\nCorect");
1053				corect++;
1054			}
1055			else
1056				printf("\nIncorect 3");
1057			break;
1058		case 78:
1059			printf("\n77. Un caz de utilizare este:");
1060			printf("\n1)	a) o capabilitate nominalizata a unei entitati structurale in cadrul unui model.");
1061			printf("\n2)	b) un obiect in afara scopului sistemului considerat dar care are interactiuni semnificative cu acesta prin cazul de utilizare respectiv.");
1062			printf("\n3)	c) o entitate structurala (un subsistem) din cadrul sistemului respectiv care cuprinde o realizare a unei functiuni.\n");
1063			scanf("%d", &var);
1064			if (var == 1)
1065			{
1066				printf("\nCorect");
1067				corect++;
1068			}
1069			else
1070				printf("\nIncorect 1");
1071			break;
1072		case 79:
1073			printf("\n78. In UML conectarea modelului de obiecte cu modelul cazurilor de utilizare se realizeaza prin aceea ca:");
1074			printf("\n1)	a) fiecare caz de utilizare corespunde cate unui obiect");
1075			printf("\n2)	b) fiecare caz de utilizare va fi realizat de un set de obiecte care lucreaza impreuna.");
1076			printf("\n3)	c) fiecare model de obiecte este realizat de un set de cazuri de utilizare care trimite secvente de mesaje.\n");
1077			printf("\n nu stiu raspunsul ,puteti pune ce vreti voi eu pun la intamplare una ");
1078			scanf("%d", &var);
1079			if (var == 3)
1080			{
1081				printf("\nCorect");
1082				corect++;
1083			}
1084			else
1085				printf("\nIncorect");
1086			break;
1087		case 80:
1088			printf("\n79. O stare este:");
1089			printf("\n1)	a) o descriere a comportamentului unui obiect in timpul intrarii,iesirii sau persistentei.");
1090			printf("\n2) 	b) o conditie de existenta a unui clasificator (clasa sau caz de utilizare) care persista o perioada semnificativa de timp si poate fi cumva distinsa fata de alte conditii similare de existenta.");
1091			printf("\n3)	c) o descriere complet constructiva de descompunere a comportamentului complex in bucati mai mici, fiecare fiind valabila in anumite conditii specifice.\n");
1092			scanf("%d", &var);
1093			if (var == 2)
1094			{
1095				printf("\nCorect");
1096				corect++;
1097			}
1098			else
1099				printf("\nIncorect 2");
1100			break;
1101		case 81:
1102			printf("\n80. Pentru identificarea cazurilor de utilizare analistul sta de vorba cu clientul si ii adreseaza intrebari cheie precum:");
1103			printf("\n1)	a) care este rolul actorilor si al sistemului in fiecare scenariu? Care sunt interactiunile (fluxurile)? Care sunt secventele de evenimente si date si posibile variatiuni?");
1104			printf("\n2)	b) care sunt actorii? Care sunt mesajele pe care le trimit si receptioneaza? Care sunt grupele care alcatuiesc cazuri de utilizare?");
1105			printf("\n3)	c) care sunt functiile primare ale sistemului? Care sunt functiile secundare ale sistemului? De ce a fost construit sistemul? Ce inlocuieste si de ce?\n");
1106			scanf("%d", &var);
1107			if (var == 3)
1108			{
1109				printf("\nCorect");
1110				corect++;
1111			}
1112			else
1113				printf("\nIncorect 3");
1114			break;
1115		case 82:
1116			printf("\n81. In UML comportamentul continual este modelat prin:");
1117			printf("\n1)	a) un limbaj propriu de simulare (SimUML)");
1118			printf("\n2)	b) nu exista posibilitati directe de simulare in UML");
1119			printf("\n3)	c) comportament de stare\n");
1120			scanf("%d", &var);
1121			if (var == 2)
1122			{
1123				printf("\nCorect");
1124				corect++;
1125			}
1126			else
1127				printf("\nIncorect 2");
1128			break;
1129		case 83:
1130			printf("\n82. Agregarea este:");
1131			printf("\n1)	a) un tip special de asociere care implica proprietatea logica sau fizica.");
1132			printf("\n2)	b) o forma tare de compozitie in care partile sunt in intregime in responsabilitatea clasei compozite");
1133			printf("\n3)	c) o relatie de tip clasa parinte/clasa descendent\n");
1134			scanf("%d", &var);
1135			if (var == 1)
1136			{
1137				printf("\nCorect");
1138				corect++;
1139			}
1140			else
1141				printf("\nIncorect 1");
1142			break;
1143		case 84:
1144			printf("\n83. Asocierile sunt:");
1145			printf("\n1)	a) relatii care se manifesta la rulare pentru a permite schimb de mesaje intre obiecte");
1146			printf("\n2)	b) relatii de colaborare definite prin existenta unui server si respectiv a unui pachet de metode");
1147			printf("\n3)	c) codificate prin existenta unei clase asociative\n");
1148			scanf("%d", &var);
1149			if (var == 1)
1150			{
1151				printf("\nCorect");
1152				corect++;
1153			}
1154			else
1155				printf("\nIncorect 1");
1156			break;
1157		case 85:
1158			printf("\n84. In UML o operatie este:");
1159			printf("\n1)	a) specificarea unui comportament");
1160			printf("\n2)	b) specificarea unui mesaj");
1161			printf("\n3)	c) descrierea unui secvente de apeluri de metode\n");
1162			scanf("%d", &var);
1163			if (var == 1)
1164			{
1165				printf("\nCorect");
1166				corect++;
1167			}
1168			else
1169				printf("\nIncorect 1");
1170			break;
1171		case 86:
1172			printf("\n85. Diagramele de secventa sunt:");
1173			printf("\n1)	a) cea mai uzuala cale de reprezentare a scenariilor");
1174			printf("\n2)	b) cea mai uzuala cale de reprezentare a cazurilor de utilizare");
1175			printf("\n3)	c) diagrame care cuprind caile de realizare a asocierilor dintre obiecte si mesaje\n");
1176			scanf("%d", &var);
1177			if (var == 1)
1178			{
1179				printf("\nCorect");
1180				corect++;
1181			}
1182			else
1183				printf("\nIncorect 1");
1184			break;
1185		case 87:
1186			printf("\n86. Tipurile de operatii sunt:");
1187			printf("\n1)	a) constructor, destructor, modificator, selector, iterator");
1188			printf("\n2)	b) ortogonale, primitive, compozite, colectii, containere");
1189			printf("\n3)	c) binare, constructor, destructor, primitive, ne-primitive\n");
1190			scanf("%d", &var);
1191			if (var == 1)
1192			{
1193				printf("\nCorect");
1194				corect++;
1195			}
1196			else
1197				printf("\nIncorect 1");
1198			break;
1199		case 88:
1200			printf("\n87. Un sablon (pattern)");
1201			printf("\n1)	a) abstractizeaza si identifica aspectele cheie ale unei structuri comune de proiectare pe care o face utila pentru crearea unui design OO, reutilizabil.");
1202			printf("\n2)	b) abstractizeaza si identifica aspectele cheie ale unei structuri comune de proiectare in care o singura sursa de informatie actioneaza ca un server pentru mai multi clienti.");
1203			printf("\n3)	c) abstractizeaza si identifica aspectele cheie ale unei structuri comune de proiectare prin utilizarea claselor abstracte si a mostenirii si a functiilor virtuale.\n");
1204			scanf("%d", &var);
1205			if (var == 1)
1206			{
1207				printf("\nCorect");
1208				corect++;
1209			}
1210			else
1211				printf("\nIncorect 1");
1212			break;
1213		case 89:
1214			printf("\n88. Sablonul Container este o buna solutie pentru cazul:");
1215			printf("\n1)	a) cand un obiect are asociere 1 la mai multi si dorim sa imbunatatim reuzabilitatea si atunci acea clasa de la capatul „1”  va gestiona un set de obiecte stocate intr-un container.");
1216			printf("\n2)b) cand devine mai usoara adaugarea unui nou container –un vector extensibil-prin crearea unei interfete care asigura clientilor serviciile cerute de acestia dar folosesc operatiile primitive ale containerelor existente.");
1217			printf("\n3)c) cand un obiect are nevoie de o implementare comuna potrivita pentru o varietate de utilizari.\n");
1218			scanf("%d", &var);
1219			if (var == 1)
1220			{
1221				printf("\nCorect");
1222				corect++;
1223			}
1224			else
1225				printf("\nIncorect 1");
1226			break;
1227		case 90:
1228			printf("\n89. Cand, in cadrul sablonului Observer, serverul primeste un apel subscribe");
1229			printf("\n1)	a) apeleaza periodic o metoda Gimme() de interogare direct a valorii urmarite");
1230			printf("\n2)	b) creaza un obiect NotificationHandle care include adresa obiectului.");
1231			printf("\n3)	c) creaza un obiect de tip ConcreteObserver care adauga stocarea locala in aributele dorite.\n");
1232			scanf("%d", &var);
1233			if (var == 3)
1234			{
1235				printf("\nCorect");
1236				corect++;
1237			}
1238			else
1239				printf("\nIncorect 3");
1240			break;
1241		case 91:
1242			printf("\n90. Un sablon (pattern) este:");
1243			printf("\n1)	a) o structura de program orientat pe obiecte");
1244			printf("\n2)b) o regula care leaga printr-o ierarhie de clase o descriere de solutie de un set de specificatii.");
1245			printf("\n3)c) o regula care exprima o relatie dintre un context,o problema si o solutie.\n");
1246			scanf("%d", &var);
1247			if (var == 3)
1248			{
1249				printf("\nCorect");
1250				corect++;
1251			}
1252			else
1253				printf("\nIncorect 3");
1254			break;
1255		case 92:
1256			printf("\n91. Sablonul Observer rezolva problema");
1257			printf("\n1)	a) in care un server trebuie sa furnizeze la cerere date citite din proces");
1258			printf("\n2)	b) in care un obiect trebuie sa afiseze periodic (observe) schimbarile survenite in valorile citite de la un senzor");
1259			printf("\n3)	c) in care o singura sursa de informatie actioneaza ca un server pentru mai multi clienti care trebuie sa isi actualizeze autonom datele cand acestea se schimba.\n");
1260			scanf("%d", &var);
1261			if (var == 3)
1262			{
1263				printf("\nCorect");
1264				corect++;
1265			}
1266			else
1267				printf("\nIncorect 3");
1268			break;
1269		case 93:
1270			printf("\n92. La un sablon Interface participa clasele:");
1271			printf("\n1)	a) Stack, List, Interface");
1272			printf("\n2)	b) Client, Server, List, Interface");
1273			printf("\n3)	c) Client, Interface, Implementation\n");
1274			scanf("%d", &var);
1275			if (var == 3)
1276			{
1277				printf("\nCorect");
1278				corect++;
1279			}
1280			else
1281				printf("\nIncorect 3");
1282			break;
1283
1284
1285		}
1286	}
1287	printf("\nRezultate corecte: %d\n", corect);
1288	getch();
1289}