Esame di Calcolatori Elettronici
Appello del 13/2/'02 (Telecomunicazioni)
Esercizio 1)
Realizzare in Assembler GNU la seguente funzione (scrivere sul file es1.s ed eseguire):
struct ss {char ca; int v; char cb[5]; };
extern "C" ss f(ss ss1, ss& ss2)
{	ss ss3; int i;
	ss2.v = ss1.v+(int)ss1.cb[3]; ss3.v = ss2.v+(int)ss1.cb[1]; 
	for (i = 0; i < 5; i++) 
		{ ss2.cb[i] = ss1.cb[i]+ss1.ca; ss3.cb[i] = ss2.cb[i]++;}
	ss3.ca=ss3.cb[2]; ss2.ca=ss3.cb[0];
	return ss3;
}

Esercizio 2)
Realizzare quanto richiesto in C++ (scrivere sul file es2.cc ed eseguire).
Siano date le seguenti dichiarazioni, contenute nel file cc.h:
class matrice
{	struct elem {char* nome; int num; };
	elem** mat; int righe, colonne;
public:	matrice(int rig, int col) {
		righe=rig; colonne=col;	mat=new elem* [rig];
		for (int r=0; r<rig;r++)
			mat[r]=new elem [col];}
	matrice() {mat=0;}
	void build(const char []);void saltras(const char nome[]); 
	void stampa();matrice operator+(const matrice&);
};
La classe matrice realizza una matrice di strutture di tipo elem. Realizzare: 1) la funzione membro build() 
che: a) cancella gli eventuali elementi gi… presenti nella matrice, b) apre in lettura il file il cui nome e' 
passato come parametro, c) legge dal file due interi che rappresentano il numero di righe ed il numero di 
colonne della matrice, d) legge dal file una stringa (al massimo di 20 caratteri) ed un numero intero fino a 
riempire la matrice (gli elementi nel file sono organizzati per righe). In caso di errore nella lettura dal file, la 
funzione stampa un messaggio di errore ed esce. 2) la funzione membro saltras() che salva la matrice nel file 
il cui nome Š passato come primo parametro in modo tale che passando il file come parametro alla funzione 
build la matrice che viene costruita risulti trasposta rispetto alla matrice originale; 3) l'operatore operator+(), 
che, se il numero di righe e di colonne delle due matrici a cui si applica l'operatore non Š uguale, stampa un 
messaggio di errore e esce; altrimenti restituisce una matrice i cui elementi hanno il campo nome ottenuto 
concatenando i corrispondenti campi nome e ponendo un underscore tra il primo ed il secondo nome (cioŠ, se 
i campi nome dei due elementi contengono "Paolo" e "Pippo", il campo nome nell'elemento corrispondente 
della matrice restituita ‚ "Paolo_Pippo") ed il campo num ottenuto sommando i corrispondenti campi num. 
La funzione stampa() stampa su uscita standard tutti gli elementi della matrice. Le funzione stampa() e' 
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 ss1 di tipo ss inizializzando il campo ca al carattere '0', 
il campo v all'intero 0 ed il campo cb con i caratteri da '1' a '5'; 2. dichiara due strutture ss2 e ss3 di tipo ss; 
3. chiama la funzione f() passandole ss1 e ss2 come primo e secondo parametro, rispettivamente, e 
assegnando la struttura restituita dalla funzione a ss3; 4. stampa su uscita standard la strutture ss2 e ss3; 5. 
dichiara quattro matrici mat1, mat2, mat3 e mat4; 6. chiama la funzione build() su mat1 passandole la stringa 
"ingr"; 7. stampa su uscita standard mat1; 8. chiama la funzione build() su mat2 passandole la stringa "ingr"; 
9. applica l'operatore somma tra mat1 e mat2 e assegna il risultato a mat3; 10. stampa su uscita standard la 
matrice mat3; 11. chiama la funzione saltras() passandole la stringa "temp" sulla matrice mat3; 12. chiama 
la funzione build() su mat4 passandole la stringa "temp"; 13. stampa su uscita standard mat4. 

Esame di Calcolatori Elettronici
Appello del 13/2/2002 - Soluzioni

# file es1.s

.text
.globl _f
_f:
	pushl %ebp
	movl %esp,%ebp
	subl $20,%esp
	pushl %esi
	pushl %ebx
	pushl %edx
	pushl %ecx
	movl 28(%ebp),%edx	#indirizzo ss2 in edx
	movsbl 23(%ebp),%ebx	#(int)ss1.cb[3]
	addl 16(%ebp),%ebx
	movl %ebx,4(%edx)	#ss2.v=ss1.v+(int)ss1.cb[3]
	movsbl 21(%ebp),%ebx	#(int)ss1.cb[1]
	addl 4(%edx),%ebx
	movl %ebx,-12(%ebp)	#ss3.v = ss2.v+(int)ss1.cb[1]
	movl $0,-20(%ebp)
for:	cmpl $5,-20(%ebp)
	jl corpo
	jmp finefor
corpo:	movl -20(%ebp),%ecx
	movb 12(%ebp), %bl
	addb 20(%ebp,%ecx), %bl
	movb %bl, 8(%edx,%ecx)	#ss2.cb[i] = ss1.cb[i]+ss1.ca
	movb %bl,-8(%ebp,%ecx)	#ss3.cb[i] = ss2.cb[i]
	incb %bl
	movb %bl, 8(%edx,%ecx)	#ss2.cb[i]++;
	incl -20(%ebp)
	jmp for
finefor:movb -6(%ebp),%bl	#ss3.ca=ss3.cb[2]
	movb %bl,-16(%ebp)
	movb -8(%ebp),%bl	#ss2.ca=ss3.cb[0]
	movb %bl,(%edx)
	leal -16(%ebp), %esi	#return ss3
	movl 8(%ebp), %eax
	movl %eax, %edi
	movl $4, %ecx
	cld
	rep
	movsl
	popl %ecx
	popl %edx
	popl %ebx
	popl %esi
	leave
	ret



Esercizio 2

//file cc.h esistente

class matrice
{	struct elem {char* nome; int num; };
	elem** mat; int righe, colonne;
public:	matrice(int rig, int col) {
		righe=rig; colonne=col;
		mat=new elem* [rig];
		for (int r=0; r<rig;r++)
			mat[r]=new elem [col];}
	matrice() {mat=0;}
	matrice operator+(const matrice&);
	void build(const char []);
	void stampa();
	void saltras(const char nome[]);
};



//file ccob.cc esistente

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

void matrice::stampa()
{
	for (int r=0; r<righe; r++)
	{
		for (int c=0; c<colonne; c++)
			cout << '(' << mat[r][c].nome << ',' <<mat[r][c].num << ')' << '\t';
		cout << endl;
	}
	cout << endl << endl;
}



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


void matrice::build(const char nome[])
{
	ifstream in(nome);
	if (!in)
	{
		cerr << "Errore nell'apertura del file " << nome << endl;
		exit(1);
	}
	if (mat!=0)
	{
		for (int r=0; r<righe; r++)
		{
			for (int c=0; c<colonne; c++)
				if (mat[r][c].nome) delete[] mat[r][c].nome;
			delete[] mat[r];
		}
		delete[] mat;
	}
	if (!(in >> righe >> colonne)) 
	{
		cerr << "Errore nella lettura del file " << endl;
		exit(1);
	}
	char leggi[20];
	mat=new elem* [righe];
	for (int r=0; r<righe;r++)
		mat[r]=new elem [colonne];
	for (int r=0; r<righe; r++)
		for (int c=0; c<colonne; c++)
		{
			if (!(in >> leggi >> mat[r][c].num)) 
			{
				cerr << "Errore nella lettura del file " << endl;
				exit(1);
			}
			mat[r][c].nome=new char [strlen(leggi)+1];
			strcpy(mat[r][c].nome,leggi);
		}
}

void matrice::saltras(const char nome[])
{
	ofstream out(nome);
	if (!out)
	{
		cerr << "Errore nell'apertura del file " << nome << endl;
		exit(1);
	} 
	out << colonne << '\t' << righe << endl;
	for (int c=0; c<colonne; c++)
	{
		for (int r=0; r<righe; r++)
			out << mat[r][c].nome << '\t' << mat[r][c].num << '\t';
		out << endl;
	}
}

matrice matrice::operator+(const matrice& m)
{	
	if (m.righe!=righe && m.colonne!=colonne)
	{
		cerr << "Non e' possibile effettuare la somma" << endl;
		exit(1);
	}
	matrice ris(righe,colonne);
	for (int r=0; r<righe; r++)
		for (int c=0; c<colonne; c++)
		{
			ris.mat[r][c].nome=new char[strlen(mat[r][c].nome)+strlen(m.mat[r][c].nome)+2];
			strcpy(ris.mat[r][c].nome,mat[r][c].nome);
			strcat(ris.mat[r][c].nome,"_");
			strcat(ris.mat[r][c].nome,m.mat[r][c].nome);
			ris.mat[r][c].num=mat[r][c].num+m.mat[r][c].num;
		}
	return ris;
}
			

Esercizio 3

//file es3.cc

#include <iostream.h>
#include "cc.h"
struct ss { char ca; int v; char cb[5]; };
extern "C" ss f(ss ss1, ss& ss2);

void stampa(const ss& s)
{
	cout << "ca= " << s.ca << endl;
	cout << "v= " << s.v << endl;
	cout << "cb[]= ";
	for (int i=0; i<5; i++) cout << s.cb[i] << ' ';
	cout << endl << endl;
}

void main()
{
	ss ss1={'0', 0, {'1','2','3','4','5'}}, ss2, ss3;
	ss3=f(ss1,ss2);
	cout << "Stampa della struttura ss2 " << endl;
	stampa(ss2);
	cout << "Stampa della struttura ss3 " << endl;
	stampa(ss3);
	matrice mat1, mat2, mat3, mat4;
	mat1.build("ingr");
	cout << "Stampa della matrice mat1 " << endl;
	mat1.stampa();
	mat2.build("ingr"); 
	mat3=mat1+mat2;
	cout << "Stampa della matrice mat3 " << endl;
	mat3.stampa();
	mat3.saltras("temp");
	mat4.build("temp");
	cout << "Stampa della matrice mat4 " << endl;
	mat4.stampa();
	
}