/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*---------------------DOMANDA 1------------------------*/
/*------------------------------------------------------*/
Si consideri il seguente metodo:

const int size = 6;
void method(int vett[])
{
	int i = 0;
	while(i < size / 2)
	{
		vett[i] = vett[size - i - 1];
		vett[size - i - 1] = vett[i] + 1;
		i++;
	}
}

Indicare il contenuto del vettore vett dopo lesecuzione del seguente frammento di codice:

	int vett[] = {1,2,3,4,5,6};
	method(vett);

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

	[X]  {6,5,4,5,6,7}
	[ ]  {6,5,4,4,3,2}
	[ ]  {4,5,6,3,2,1}
	[ ]  {4,5,6,4,3,2}
	[ ]  {5,4,3,4,5,6}

/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*---------------------DOMANDA 2------------------------*/
/*------------------------------------------------------*/
Si consideri il seguente metodo:

	const int size = 6;
	int method(int vett[])
	{
		int j = 0;
		for (int i = 0 ; i < size ; i++)
			if (vett[i] > j )
				j = j + vett[i];
			else
				j = j - vett[i];
		return j;
	}

Indicare il valore della variabile res dopo lesecuzione del seguente frammento di codice:

	int vett[] = {1,2,3,4,5,6};
	int res = method(vett);

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

	[ ]  0
	[ ]  1
	[ ]  2
	[X]  3
	[ ]  4

/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*---------------------DOMANDA 3------------------------*/
/*------------------------------------------------------*/
Si considerino le seguenti dichiarazioni:

	class A {
		public:		void a1();
		protected:	void a2();
		private:	void a3();
	};

	class B: protected  A {
		public:		void b1();
		protected:	void b2();
		private:	void b3();
	};

	class C: private B {
		private:
			void c3() {
				a1();	//LINE 1
				a2();	//LINE 2
				a3();	//LINE 3
				b1();	//LINE 4
				b2();	//LINE 5
				b3();	//LINE 6
			}
	};

Indicare l'insieme di tutte e sole linee di codice corrette.

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

	[ ]  {1,2,3,4,5,6}
	[X]  {1,2,4,5}
	[ ]  {1,4,5}
	[ ]  {1,4}
	[ ]  {4,5}

/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*---------------------DOMANDA 4------------------------*/
/*------------------------------------------------------*/
Data la seguente classe

	class frazione
	{
		private:
			int num, den;
		public:
			frazione();			//Linea1
			frazione(const frazione & f);	//Linea2
			frazione(int n, int d);		//Linea3
			frazione(int n);		//Linea4
	}

Indicare l'affermazione corretta

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

	[ ]  La "Linea3" indica il costruttore di copia, il quale, in questo caso e' superfluo
	[X]  La "Linea2" indica il costruttore di copia, il quale, in questo caso e' superfluo
	[ ]  La "Linea1" e la "Linea4" sono superflue
	[ ]  La "Linea2" indica il costruttore di copia, il quale, in questo caso e' necessario
	[ ]  La "Linea3" indica il costruttore di copia, il quale, in questo caso e' necessario

/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*---------------------DOMANDA 5------------------------*/
/*------------------------------------------------------*/
Con riferimento ai due metodi seguenti indicare indicare l'affermazione corretta

	char & operator[](int position);
	char operator[](int position) const;

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

	[X]  Il primo permette di modificare l'oggetto che lo invoca mentre il sencondo no
	[ ]  Il primo e' sintatticamente scorretto
	[ ]  Il secondo puo' essere invocato solo su oggetti dichiarati costanti
	[ ]  Il primo restituisce un puntatore ad un'area dinamice
	[ ]  Sono equivalenti

/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*---------------------DOMANDA 6------------------------*/
/*------------------------------------------------------*/
Se una classe myLista contiente un metodo virtuale puro, indicare l'affermazione corretta


	[X] Non e' possibile creare oggetti di myLista
	[ ] myLista deve avere solo metodi virtuali
	[ ] myLista deve necessariamente avere un costruttore
	[ ] myLista e' una classe derivata
	[ ] il metodo virtuale puro di myLista non puo' essere cambiato nelle sottoclassi

/*------------------------------------------------------*/
/*------------------------------------------------------*/
/*------------------------------------------------------*/