Soluzioni: Lezione 1
Contents
Soluzioni: Lezione 1¶
Esercizio 1.1¶
esercizio01.cpp
/*
c++ -o esercizio01 esercizio01.cpp
Esercizio: scrivere un programma che assegni il valore di una variabile ad
un'altra utilizzando un puntatore. Farsi inoltre stampare a terminale
i valori e gli indirizzi di ogni variabile prima e dopo l'assegnazione
*/
#include <iostream>
int main()
{
int balance; // Dichiara un int
int value; // Dichiara altro int
int* balance_ptr; // Dichiara un puntatore ad un int
balance = 3200; // Assegna un valore a balance
balance_ptr = &balance; // Assegna come valore a balance_ptr l'indirizzo della variabile balance
value = *balance_ptr; // Assegna il valore del puntatore balance_ptr alla variabile value
std::cout << "balance is: " << balance << std::endl;
std::cout << "balance_ptr is: " << balance_ptr << std::endl;
std::cout << "value is: " << value << std::endl;
return 0;
}
Esercizio 1.2¶
esercizio02.cpp
/*
c++ -o esercizio02 esercizio02.cpp
Esercizio: dichiarare un puntatore e poi cercare di assegnargli direttamente
un valore numerico. Cosa succede? Perchè?
*/
#include <iostream>
int main()
{
int* pointer;
pointer = 5;
std::cout << "Valore scritto in pointer: " << pointer << std::endl;
return 0;
}
Esercizio 1.3¶
esercizio03.cpp
/*
c++ -o esercizio03 esercizio03.cpp
Esercizio: utilizzare new e delete per creare e distruggere
una variabile double ed un array di double
*/
#include <iostream>
int main()
{
double* valore = new double(1.5);
std::cout << "Valore creato con la new: " << *valore << std::endl;
delete valore;
int dim = 5;
double* array = new double[dim];
for (int i = 0; i < dim; i++)
{
array[i] = 2.2 * i;
std::cout << "Valore [" << i << "] dell'array creato con la new: "
<< array[i] << std::endl;
}
delete [] array;
return 0;
}
Esercizio 1.4¶
esercizio04.cpp
/*
c++ -o esercizio04 esercizio04.cpp
Esercizio: realizzare una funzione che risolve un’equazione di secondo grado: ax2 + bx + c = 0
*/
#include <iostream>
#include <cmath>
bool solve2ndDegree(double* par, double* x)
// equation: ax^2 + bx + c
// par[0] = a
// par[1] = b
// par[2] = c
// x[0] = x_low
// x[1] = x_high
// if determinant < 0: return false
// else: return true
{
double a = par[0];
double b = par[1];
double c = par[2];
double det = b*b - 4.*a*c;
if (det < 0)
{
std::cout << "Negative determinant: " << det << std::endl;
return false;
}
double x_low = (-b - sqrt(det)) / (2.*a);
double x_high = (-b + sqrt(det)) / (2.*a);
x[0] = x_low;
x[1] = x_high;
return true;
}
int main (int argc, char** argv)
{
double par[3];
double x[2];
par[0] = 1;
par[1] = 2;
par[2] = 3;
bool solved = solve2ndDegree(par,x);
if (solved == true)
std::cout << "Equation solved. x1 = " << x[0] << " x2 = " << x[1] << std::endl;
else
std::cout << "Equation not solved" << std::endl;
return 0;
}
Esercizio 1.5¶
esercizio05.cpp
/*
c++ -o esercizio05 esercizio05.cpp
Esercizio: rifare l’esercizio su media/varianza realizzando un'unica funzione
che calcola entrambe (fare uso di puntatori/referenze)
*/
#include <iostream>
#define DIM 10
void DataAnalysis(double* data, int dim, double& mean, double& var)
{
for (int i = 0; i < dim; i++)
{
mean += data[i];
var += data[i]*data[i];
}
mean = mean / dim;
var = (var/dim - mean*mean) * dim / (dim-1);
}
int main (int argc, char** argv)
{
int dim = DIM;
double* data = new double[dim];
double mean;
double var;
for (int i = 0; i < dim; i++)
{
data[i] = i;
}
DataAnalysis(data, dim, mean, var);
std::cout << "Sample mean: " << mean << "\tSample variance: " << var << std::endl;
delete[] data;
return 0;
}
Esercizio 1.6¶
esercizio06.cpp
/*
c++ -o esercizio06 esercizio06.cpp
Esercizio: scrivere un programma che, dato un array di n interi,
lo ordini dal piu` piccolo al piu` grande
L'algoritmo qui riportato e` chiamato "bubble sort", ed ha una
complessita` media, o equivalentemente un tempo di esecuzione
medio, che scala come O(n^2). Un algoritmo che ha complessita`
media inferiore, O(n*log(n)), e` per esempio il "quick sort"
*/
#include <iostream>
#define DIM 10
void SortArray(double* myArray, int dim)
{
bool flag = true;
for (int i = 1; (i < dim && flag == true); i++)
{
flag = false;
for (int j = 0; j < (dim - i); j++)
{
if (myArray[j+1] < myArray[j])
{
int temp = myArray[j];
myArray[j] = myArray[j+1];
myArray[j+1] = temp;
flag = true;
}
}
}
}
int main (int argc, char** argv)
{
double* data = new double[DIM];
std::cout << "Un-sorted values: " << std::endl;
for (int i = 0; i < DIM; i++)
{
data[i] = DIM-i;
std::cout << "Val " << i << " = " << data[i] << std::endl;
}
SortArray(data, DIM);
std::cout << "\nSorted values: " << std::endl;
for (int i = 0; i < DIM; i++)
{
std::cout << "Val " << i << " = " << data[i] << std::endl;
}
delete[] data;
return 0;
}
Esercizio 1.7¶
esercizio07.cpp
/*
c++ -o esercizio07 esercizio07.cpp
Esercizio: riscrivere la creaVettore senza fare uso dell'istruzione return
*/
#include <iostream>
// ##########################
// # Solution with pointers #
// ##########################
void creaVettore (int dim, int** array)
{
*array = new int[dim];
}
// ############################
// # Solution with references #
// ############################
// void creaVettore (int dim, int*& array)
// {
// array = new int[dim];
// }
int main()
{
int dim = 0;
std::cout << "Insert the dimension of the array: ";
std::cin >> dim;
if (dim < 0)
{
std::cout << "Negative number: " << dim << std::endl;
return -1;
}
// ###################################
// # Dynamic allocation of the array #
// ###################################
int* vec;
// ##########################
// # Solution with pointers #
// ##########################
creaVettore(dim,&vec);
// ############################
// # Solution with references #
// ############################
// creaVettore(dim,vec);
// Fill the array
for (int i = 0; i < dim; i++)
{
vec[i] = i+1;
}
// Print the elements of the array
for (int i = 0; i < dim; i++)
{
std::cout << "Content of the cell " << i << " : " << vec[i] << std::endl;
}
delete[] vec;
return 0;
}