Esame di Calcolatori Elettronici
Appello del 30/1/'03 (Telecomunicazioni)
Esercizio 1)
Realizzare in Assembler GNU la seguente funzione (scrivere sul file es1.s ed eseguire):
struct sttu { int a[4]; int b[4]; };
extern "C" void f(sttu s1, sttu& s2, int v1[4], int v2[4])
{	int i;
	for (i = 0; i < 4; i++)
	{	if (s1.a[i] > 0) 
			v1[i] = s1.b[i]*s1.b[i]; 
		else v1[i] = s1.b[3-i];
		v2[i] = v1[i] + s1.a[i/2];	
	}
	s2 = s1;
}

Esercizio 2)
Realizzare quanto richiesto in C++ (scrivere sul file es2.cc ed eseguire).
Siano date le seguenti dichiarazioni, contenute nel file cc.h:
struct element { char nome[15]; char cognome[15]; };
class matrice 
{	element** mat; int rig, col;
public: 
	matrice()	{ mat = 0; rig=col=0;}
	void stampa(); 	void build(const char nome[]);
	void salvaTras(const char nome[]); matrice& operator-=(const matrice& m);
};
La classe matrice realizza una matrice di strutture di tipo element. Realizzare: 1) la funzione membro build() 
che inizializza la matrice utilizzando il file il cui nome è passato come parametro (il file contiene due interi 
che rappresentano, rispettivamente, il numero rig di righe ed il numero col di colonne della matrice; quindi 
contiene rig linee composte da col coppie di stringhe che contengono al massimo 14 caratteri); 2) la funzione 
membro salvaTras() che salva la matrice, trasponendola, nel file il cui nome è passato come parametro; la 
matrice deve essere salvata nel file nello stesso formato descritto per la funzione build(); 3) la funzione 
membro operator-=() che se sia il campo nome che il campo cognome di elementi corrispondenti nella 
matrice su cui è chiamata la funzione e nella matrice passata come parametro sono uguali, copia sia nel 
campo nome che nel campo cognome dell'elemento della matrice su cui è chiamata la funzione la stringa "-"; 
la funzione stampa un messaggio di errore se le due matrici non hanno la stessa dimensione; la funzione 
restituisce la matrice su cui è applicata la funzione.
La funzione membro stampa() stampa su uscita standard gli elementi della matrice. La funzione stampa() è 
implementata nel file ccob.o.

Esercizio 3)
Realizzare quanto richiesto in C++ (scrivere sul file es3.cc ed eseguire).
Scrivere un programma che: 1. dichiara una struttura s1 di tipo sttu inizializzando i campi a e b con 
rispettivamente gli interi da –1 a 2 e da 0 a 3; 2. dichiara una struttura s2 di tipo sttu; 3. dichiara due vettori 
v1 e v2 di quattro interi; 4. chiama la funzione f() passandole nell'ordine s1, s2, v1 e v2; 5. stampa su uscita 
standard la struttura s2 ed i vettori v1 e v2; 6. dichiara due oggetti mat e mat1 di tipo matrice; 7. invoca la 
funzione build() su mat passandole la stringa "ingr"; 8. stampa su uscita standard mat; 9. chiama la funzione 
salvaTras() su mat passandole la stringa "temp"; 10. chiama la funzione build() su mat1 passandole la stringa 
"temp"; 11. stampa su uscita standard mat1; 12. chiama l'operatore operator-=() su mat1 passando come 
argomento mat; 13. stampa su uscita standard mat1.


Esame di Calcolatori Elettronici
Appello del 30/1/2003 - Soluzioni

# file es1.s

.text
.globl _f
_f:
	pushl %ebp
	movl %esp,%ebp
	subl $4,%esp
	pushl %edi
	pushl %esi
	pushl %ebx
	pushl %eax
	pushl %edx
	movl $0,-4(%ebp)		
for:	cmpl $4,-4(%ebp)		
	jl corpo
	jmp fine
corpo:	movl -4(%ebp),%ecx
	cmpl $0,8(%ebp,%ecx,4)		#s1.a[i]>0
	jle else
	movl 44(%ebp),%ebx		#v1[i]=s1.b[i]*s1.b[i]
	movl 24(%ebp,%ecx,4), %eax
	imull 24(%ebp,%ecx,4)
	movl %eax,(%ebx,%ecx,4)  
	jmp fineif
else:	movl $3,%edx			#v1[i]=s1.b[3-i];
	subl %ecx,%edx
	movl 44(%ebp),%ebx
	movl 24(%ebp,%edx,4), %eax
	movl %eax,(%ebx,%ecx,4) 
fineif:	movl %ecx,%edx			#v2[i]=v1[i]+s1.a[i/2]
	sarl $1,%edx
	movl 8(%ebp,%edx,4),%eax 
	movl 48(%ebp),%edi
	addl (%ebx,%ecx,4),%eax
	movl %eax,(%edi,%ecx,4)
	incl -4(%ebp)
	jmp for
fine:	movl 40(%ebp),%edi		#s2=s1
	leal 8(%ebp),%esi
	cld
	movl $8,%ecx
	rep
	movsl
	popl %edx
	popl %eax
	popl %ebx
	popl %esi
	popl %edi
	leave
	ret


Esercizio 2

// file cc.h esistente


struct element { char nome[15]; char cognome[15]; };
class matrice 
{	element** mat; int rig, col;
public: 
	matrice()
	{	mat = 0; rig=col=0;}
	void stampa(); 
	void build(const char nome[]);
	void salvaTras(const char nome[]);
	matrice& operator-=(const matrice& m);
};





//file ccob.cc esistente
#include <iostream.h>
#include "cc.h"

void matrice::stampa()
{	for (int i=0; i<rig; i++)
	{	for (int j=0; j<col; j++)
		cout << "mat[" << i << "][" << j << "]=("
		     << mat[i][j].nome << ',' << mat[i][j].cognome << ")\t";
		cout << endl;
	}
}




//file es2.cc
#include <fstream.h>
#include "cc.h"
#include <string.h>

void matrice::build(const char nome[])
{
	ifstream in(nome);
	if (!in)
	{
		cerr << "Errore nell'apertura del file " << nome << endl;
		exit(1);
	}
	if (!(in>>rig>>col))
	{
		cerr << "Errore nella lettura del numero di righe e di colonne " << endl;
		exit(1);
	}
	mat = new element*[rig];
	for (int i=0; i<rig; i++)
	{	
		mat[i]=new element[col];
		for (int j=0; j<col; j++)	
			if (!(in>>mat[i][j].nome>>mat[i][j].cognome))
			{
				cerr << "Errore nella lettura del nome e cognome " << endl;
				exit(1);
			}
	}	
	
}



void matrice::salvaTras(const char nome[])
{	
	ofstream out(nome);
	if (!out)
	{
		cerr << "Errore nell'apertura del file " << nome << endl;
		exit(1);
	}
	out << col << endl << rig << endl;
	for (int i=0; i<col; i++)
	{
		for (int j=0; j<rig; j++)
			out<<mat[j][i].nome<<' '<< mat[j][i].cognome << '\t';
		out << endl;
	}
}

matrice& matrice::operator-=(const matrice& m)
{	
	if ((rig!=m.rig)||(col!=m.col))
	{	
		cerr << "Le due matrici hanno un numero differente di righe e di colonne" << endl;
		exit(1);
	}
	for (int r=0; r<rig; r++)
		for (int c=0; c<col; c++)
		{	
			if (!strcmp(mat[r][c].nome,m.mat[r][c].nome) && 
				!strcmp(mat[r][c].cognome,m.mat[r][c].cognome))
			{
				strcpy(mat[r][c].nome,"-");
				strcpy(mat[r][c].cognome,"-");
			}
		}
	return *this;
}

	
		

Esercizio 3

//file es3.cc

#include <iostream.h>
#include "cc.h"

struct sttu { int a[4]; int b[4]; };
extern "C" void f(sttu s1, sttu& s2, int v1[4], int v2[4]);

void stampa(const sttu& s)
{
	cout << "a[]= ";
	for (int i=0; i<4; i++)
		cout << s.a[i] << '\t';
	cout << endl;
	cout << "b[]= ";
	for (int i=0; i<4; i++)
		cout << s.b[i] << '\t';
	cout << endl;
}

void main()
{
	sttu s1={{-1,0,1,2},{0,1,2,3}},s2;
	int v1[4],v2[4];
	f(s1,s2,v1,v2);
	cout << "Stampa di s2 " << endl;
	stampa(s2);
	cout << "Stampa di v1 " << endl;
	for (int i=0; i<4; i++)
		cout << v1[i] << '\t';
	cout << endl;
	cout << "Stampa di v2 " << endl;
	for (int i=0; i<4; i++)
		cout << v2[i] << '\t';
	cout << endl;
	matrice mat, mat1;
	mat.build("ingr");
	cout << "Stampa della matrice mat" << endl;
	mat.stampa();
	mat.salvaTras("temp");
	mat1.build("temp");
	cout << "Stampa della matrice mat1" << endl;
	mat1.stampa();
	mat1-=mat;
	cout << "Stampa della matrice mat1" << endl;
	mat1.stampa();
	
}