Esercizi cpp

[Il linguaggio di programmazione] C rende facile spararti su un piede; C++ lo rende più difficile, ma quando lo fai, ti fa saltare via l'intera gamba.
Bjarne Stroustrup

Esercizi cpp

🙂

Scrivere la dichiarazione di una classe per la gestione delle frazioni (somma, sottrazione, prodotto, rapporto). Tutte le frazioni restituite devono essere fatte di numeri primi fra loro.

attributi: numeratore, denominatore
costruttore:
metodi: addizione, sottrazione, moltiplicazione, divisione.
usare explicit, const, virtual, abstract ecc. secondo necessità

Soluzione

class Ratio {
private:
	// attributi
	int num, den;
public:
	// costruttori
	explicit Ratio();
	explicit Ratio(int num, int den);
	// metodi: getter, setter
	int getnum() const;
	int getden() const;
#if 0
	// metodi: stampa, somma, sottrazione, prodotto, rapporto
	void show(std::ostream & os) const;
	Ratio add(const Ratio & rhs) const;
	Ratio sub(const Ratio & rhs) const;
	Ratio mul(const Ratio & rhs) const;
	Ratio div(const Ratio & rhs) const;
	bool islesser(const Ratio & rhs) const;
#else
	// oppure
	friend std::ostream & operator<<(std::ostream & os, const Ratio & value);
	Ratio operator+(const Ratio & rhs) const;
	Ratio operator-(const Ratio & rhs) const;
	Ratio operator*(const Ratio & rhs) const;
	Ratio operator/(const Ratio & rhs) const;
	Ratio & operator+=(const Ratio & rhs);
	Ratio & operator-=(const Ratio & rhs);
	Ratio & operator*=(const Ratio & rhs);
	Ratio & operator/=(const Ratio & rhs);
	bool operator<(const Ratio & rhs) const;
#endif
};
int main() {
	Ratio r1(1, 3), r2(1, 6);
	r1.add(r2).show(std::cout);
	// oppure
	std::cout << r1+r2 << std::endl;
	return 0;
}

🙂

Scrivere la dichiarazione di una classe per la gestione degli insiemi (unione, intersezione, differenza, differenza simmetrica, appartenenza, ...)

attributi: ...
costruttore: ...
usare explicit, const, virtual, abstract ecc. secondo necessità
Soluzione classe cbitset.h bitset.cpp
Soluzione template tbitset.h tbitset.cxx

main main2.cpp

#include<cstdint>
class Bitset {
private:
	// attributi
//	static const unsigned m_size = 1024;
//	uint8_t m_data[128];	// 8 bit*128=1024 bit
//	std::array m_data;
//	std::vector m_data;
	std::valarray m_data;	// scelta consigliata
public:
	// costruttori
	explicit Bitset();
#if 0
	// metodi: streaming, unione, intersezione, differenza
	std::ostream & show(std::ostream & os) const;
	Bitset union(const Bitset & rhs) const;
	Bitset intersect(const Bitset & rhs) const;
	Bitset difference(const Bitset & rhs) const;
	bool islesser(const Bitset & rhs) const;
#else
	// oppure
	friend std::ostream & operator<<(std::ostream & os, const Bitset & value);
	Bitset operator+(const Bitset & rhs) const;
	Bitset operator*(const Bitset & rhs) const;
	Bitset operator-(const Bitset & rhs) const;
	Bitset & operator+=(const Bitset & rhs);
	Bitset & operator*=(const Bitset & rhs);
	Bitset & operator-=(const Bitset & rhs);
	bool operator<(const Bitset & rhs) const;
#endif
};
int main() {
	Bitset bs1, bs2;
	bs1.add(bs2).show();
	// oppure
	std::cout << bs1+bs2 << std::endl;
	return 0;
}

🙂

Scrivere la dichiarazione di una classe per la gestione dei numeri complessi.

usare explicit, const, virtual, abstract ecc. secondo necessità

Soluzione C Soluzione C++

class Complex {
private:
	// attributi
	float m_real, m_imag;
public:
	// costruttori
	explicit Complex();
	explicit Complex(float re, float im);
	// metodi: getter, setter
	float real() const;
	float imag() const;
#if 0
	// metodi: streaming, somma, sottrazione, prodotto, rapporto
	friend std::ostream & show(std::ostream & os) const;
	Complex add(const Complex & rhs) const;
	Complex sub(const Complex & rhs) const;
	Complex mul(const Complex & rhs) const;
	Complex div(const Complex & rhs) const;
#else
	// oppure
	friend std::ostream & operator<<(std::ostream & os, const Complex & z);
	Complex operator+(const Complex & rhs) const;
	Complex operator-(const Complex & rhs) const;
	Complex operator*(const Complex & rhs) const;
	Complex operator/(const Complex & rhs) const;
	Complex & operator+=(const Complex & rhs);
	Complex & operator-=(const Complex & rhs);
	Complex & operator*=(const Complex & rhs);
	Complex & operator/=(const Complex & rhs);
	// metodi: pow, root, cos, sin, exp, log
	friend Complex pow(unsigned n);
	friend Complex root(unsigned n);
	friend Complex cos(const Complex & z);
	friend Complex sin(const Complex & z);
	friend Complex exp(const Complex & z);
	friend Complex log(const Complex & z);
#endif
	// conversione di tipo
	operator std::complex() const;
};
int main() {
	Complex z1, z2;
	z1.add(z2).show();
	// oppure
	std::cout << z1+z2 << std::endl;
	return 0;
}

🙂

Scrivere la dichiarazione di una classe per la gestione dei vettori.

attributi: ...
costruttore: ...
metodi: somma, sottrazione, prodotto, rapporto.
usare explicit, const, virtual, abstract ecc. secondo necessità

Soluzione

class Vector3() {
private:
	float m_x, m_y, m_z;
public:
	// costruttori
	explicit Vector3();
	explicit Vector3(float x, float y, float z);
	// metodi: getter, setter
	float x();
	float y();
	float z();
#if 0
	// metodi: streaming
	std::ostream & show(std::ostream & os);
	// metodi: somma, sottrazione, prodotto, rapporto
	Vector3 add(const Vector3 & rhs) const;
	Vector3 sub(const Vector3 & rhs) const;
	float ps(const Vector3 & rhs) const;
	Vector3 pv(const Vector3 & rhs) const;
#else
	// oppure:
	friend std::ostream & operator<<(std::ostream & os, const Vector3 & rhs);
	Vector3 operator+(const Vector3 & rhs) const;
	Vector3 operator-(const Vector3 & rhs) const;
	float operator*(const Vector3 & rhs) const;
	Vector3 operator^(const Vector3 & rhs) const;
	Vector3 operator+=(const Vector3 & rhs);
	Vector3 operator-=(const Vector3 & rhs);
	float operator*=(const Vector3 & rhs);
	Vector3 operator^=(const Vector3 & rhs);
#endif
};
int main() {
	Vector3 v1, v2;
	v1.add(v2).show();
	// oppure
	std::cout << v1+v2 << std::endl;
	return 0;
}

🙂

Scrivere la dichiarazione di una classe per la gestione dei polinomi

attributi: grado polinomio
attributi: coefficienti polinomio
costruttore, parametri: ascisse e ordinate note.
metodi di valutazione: monovalore e multivalore (array)
usare explicit, const, virtual, abstract ecc. secondo necessità

Soluzione

class Polynomial {
private:
//	unsigned m_degree;
//	float * m_coeff;
//	std::array m_coeff;
//	std::vector m_coeff;
	std::valarray m_coeff;	// scelta consigliata
public:
	// costruttori
	explicit Polynomial(unsigned degree);
	Polynomial(const Polynomial & rhs);	// copy constructor
	Polynomial(Polynomial && rhs);	// move constructor (solo C++11)
	Polynomial & operator=(const Polynomial & rhs);	// copy assignment
	Polynomial & operator=(const Polynomial && rhs);	// move assignment (solo C++11)
	~Polynomial();
#if 0
	// metodi: streaming
	std::ostream & show(std::ostream & os);
	// metodi: somma, sottrazione, prodotto, rapporto
	Polynomial add(const Polynomial & rhs) const;
	Polynomial sub(const Polynomial & rhs) const;
	Polynomial mul(const Polynomial & rhs) const;
	Polynomial div(const Polynomial & rhs) const;
#else
	friend std::ostream & operator<<(std::ostream & os, const Polynomial & v);
	Polynomial operator+(const Polynomial & rhs) const;
	Polynomial operator-(const Polynomial & rhs) const;
	Polynomial operator*(const Polynomial & rhs) const;
	Polynomial operator/(const Polynomial & rhs) const;
	Polynomial & operator+=(const Polynomial & rhs);
	Polynomial & operator-=(const Polynomial & rhs);
	Polynomial & operator*=(const Polynomial & rhs);
	Polynomial & operator/=(const Polynomial & rhs);
#endif
	float eval(float x);
};
int main() {
	Polynomial p1(3), p2(3);
	std::cout << p1 << std::endl;
	std::cout << p2 << std::endl;
	std::cout << p1+p2 << std::endl;
	std::cout << p1-p2 << std::endl;
	std::cout << p1*p2 << std::endl;
	std::cout << p1/p2 << std::endl;
	std::cout << p1+=p2 << std::endl;
	std::cout << p1-=p2 << std::endl;
	std::cout << p1*=p2 << std::endl;
	std::cout << p1/=p2 << std::endl;

	{	// Rule of three

		// copy costructor
		Polynomial p3(p1);
		Polynomial p4=p2;
		Polynomial p5(std::copy(p1));
		Polynomial p6=std::copy(p2);

		// operator= (copy assignment)
		p3=p1;
		p3=std::copy(p1);

		// destructor
	}
	{	// Rule of five (completion)

		// initialization (move costructor, solo C++11)
		Polynomial p3(std::move(p1));
		Polynomial p4=std::move(p2);

		// function argument passing: f(std::move(a)); f pass by value
		p3.add(std::move(p1));
		// function return: return a; inside a function such as T f(), where a is of type T which has a move constructor. 
		return p3;

		// operator= (move assignment, solo C++11)
		p3=std::move(p1);
	}

	return 0;
}

🙂

Scrivere la dichiarazione di una classe per l'interpolazione numerica

attributi: coefficienti polinomio in caso di polinomio monotratto
attributi: coefficienti polinomio in caso di funzione polinomiale a tratti
costruttore, parametri: ascisse e ordinate note.
metodi di valutazione: monovalore e multivalore (array)
usare explicit, const, virtual, abstract ecc. secondo necessità

Soluzione

class Interpolate {
private:
	float * m_coeff;
	std::vector m_coeff;
public:
	// costruttori
	explicit Interpolate(std::vector & x, std::vector & y);
	// metodi: streaming
	std::ostream & show(std::ostream & os);
	// metodi: compute (in overload)
	float compute(float x);
	std::vector compute(std::vector & x);
};
int main() {
	std::vector x = { 0.0, 0.50, 1.0, 1.50, 2.0, };
	std::vector y = { 0.0, 0.25, 1.0, 2.25, 4.0, };
	Interpolate i(x, y);
	std::cout << i.compute(1.25) << std::endl;
	return 0;
}

😐

Scrivere la dichiarazione di una classe per l'integrazione numerica

attributi: ...
costruttore: ...
metodi: ...
usare explicit, const, virtual, abstract ecc. secondo necessità

Soluzione

class Integrate {
private:
public:
	// costruttori
	explicit Integrate();
	Integrate(float x, float y, float z);
	Integrate(const Integrate & v);
	// metodi: getter, setter
	float x() const;
	float y() const;
	float z() const;
	// metodi: streaming
	std::ostream & show(std::ostream & os);
	// metodi: somma, sottrazione, prodotto, rapporto
	Integrate pv(const Integrate & rhs);
};
int main() {
	Integrate i;
	std::cout << i << std::endl;
	return 0;
}

🙁

Scrivere la dichiarazione di una classe per la risoluzione dei sistemi lineari

...
usare explicit, const, virtual, abstract ecc. secondo necessità

Soluzione

class Matrix {
private:
	unsigned m_size;
	float * m_mat;
public:
	// costruttori
	Matrix(unsigned n);
	Matrix(const Matrix & m);	// copy constructor
	Matrix(Matrix && m);	// move constructor
	~Matrix();			// destructor
	// metodi: altro
	float det() const;
	float trace() const;
	Matrix inv() const;
#if 0
	// metodi: streaming, somma, sottrazione, prodotto
	std::ostream & show(std::ostream & os);
	Matrix add(const Matrix & rhs) const;
	Matrix sub(const Matrix & rhs) const;
	Matrix mul(const Matrix & rhs) const;
#else
	// oppure
	friend std::ostream & show(std::ostream & os, const Matrix & value);
	Matrix operator+(const Matrix & rhs) const;
	Matrix operator-(const Matrix & rhs) const;
	Matrix operator*(const Matrix & rhs) const;
	Matrix & operator+=(const Matrix & rhs);
	Matrix & operator-=(const Matrix & rhs);
	Matrix & operator*=(const Matrix & rhs);
	float & operator()(unsigned row, unsigned col);
#endif
};
int main() {
	Matrix matrix(4);
	std::cout << matrix << std::endl;
	std::cout << matrix1+matrix2 << std::endl;
	std::cout << matrix1-matrix2 << std::endl;
	std::cout << matrix1*matrix2 << std::endl;
	std::cout << (matrix1^matrix2) << std::endl;
	return 0;
}

🙁

Scrivere la dichiarazione di una classe per la gestione di un contatore

Soluzione

usare explicit, const, virtual, abstract ecc. secondo necessità

class Counter {
private:
	unsigned m_value;
public:
	// costruttori
	explicit Counter();
	// metodi: getter
	unsigned value() const;
#if 0
	// streaming
	std::ostream show(std::ostream & os) const;
	// metodi: altro
	void inc();
	void dec();
#else
	// oppure
	friend std::ostream & operator<<(std::ostream & os, const Counter & v);
	Counter & operator++();
	Counter & operator++(int);
	Counter & operator--();
	Counter & operator--(int);
#endif
};
int main() {
	Counter c;
	std::cout << c << std::endl;
	std::cout << ++c << std::endl;
	std::cout << c++ << std::endl;
	std::cout << --c << std::endl;
	std::cout << c-- << std::endl;
	return 0;
}

🙁

Scrivere la dichiarazione di una classe per la gestione di sondaggi

Soluzione

usare explicit, const, virtual, abstract ecc. secondo necessità

class Survey {
private:
//	unsigned m_size;
//	unsigned m_value[4];
	std::vector m_value;	// scelta consigliata
//	std::valarray m_value;
public:
	// costruttori
	explicit Survey();
	explicit Survey(unsigned n);
	// metodi: getter
	unsigned size() const;
	void vota(size_t x);
#if 0
	// streaming
	std::ostream show(std::ostream & os) const;
	// metodi: altro
#else
	// oppure
	friend std::ostream & operator<<(std::ostream & os, const Survey & v);
	unsigned & operator[](unsigned index);
#endif
};
int main() {
	Survey s(3);
	s.vota(2);
	s.vota(1);
	s.vota(2);
	s.vota(1);
	s.vota(0);
	s.vota(1);
	std::cout << s << std::endl;
	std::cout << s[0] << std::endl;
	std::cout << s[1] << std::endl;
	std::cout << s[2] << std::endl;
	return 0;
}

🙁

Scrivere la dichiarazione di una classe per la gestione di stringhe

Soluzione

usare explicit, const, virtual, abstract ecc. secondo necessità

class String {
private:
	unsigned m_length;
	char * m_cstr;	// scelta consigliata
public:
	// costruttori
	explicit String();
	explicit String(const char * str);
	// metodi: getter
	unsigned length() const;
	unsigned size() const;
}

Programmazione ad oggetti in linguaggio C++: esercizi risolti (edutecnica.it)

Realizza una classe 'contatore' che contiene una variabile intera 'valore' come attributo e due metodi, il primo è un costruttore senza parametri che inizializza 'valore' a 0 il secondo incrementa semplicemente 'valore ' di 1 tutte le volte che viene invocato. Esegui il test del programma con un ciclo for. Soluzione
Scrivi una classe D (data) i cui oggetti possano essere inizializzati come: d(22,08,01); implementare il costruttore, il metodo out() per la stampa a video, il metodo mod(gg,mm,aa) per consentirne la modifica e un metodo val() per consentire la validazione della data. Soluzione
Implementare un algoritmo di crittografia basato su una classe C che codifica una stringa di caratteri in ingresso in una stringa crittata illegibile. Il sistema deve funzionare attraverso una chiave numerica che prende tutte le occorrenze di ogni lettera della stringa e le sostituisce con la lettera che sta in k (chiave numerica) posizioni più a destra nell'ordine alfabetico. codice di Cesare Soluzione Se k è negativa lo spostamento deve avvenire verso sinistra.
Scrivi un programma che preveda la classe X che possa essere inizializzata indifferentemente con un numero binario (max 8 bit) o decimale e possa restituire in uscita lo stesso numero, indifferentemente in formato binario (max 8 bit) o decimale. Soluzione
Scrivere una classe C (cronometro) che svolga operazioni di cronometraggio del tempo. Deve essere dotata di metodi start(), stop(), per far partire e fermare il cronometro. Deve poi, esserci una classe print() per stampare l'intervallo di tempo misurato. Soluzione
Scrivi un programma per manipolare stringhe e numeri che implementi un metodo somma() che chiamato in questi modi: somma(2,3) restituisce in output 5 somma("coco", "nut") restituisce in output 'coconut'. Il programma deve essere costituito da tre classi la classe O (operazione) che implementa i metodi per la manipolazione dei dati e le due classi derivate dalla classe O; N, per l'acquisizione e la restituzione di numeri e la classe S per l'acquisizione e la restituzione di stringhe. Soluzione
Scrivi un programma che istanziata una classe T permetta ad un oggetto di tale classe di comportarsi indifferentemente come una coda (il primo entrante è il primo uscente) oppure come una pila (il primo entrante è l'ultimo uscente). La classe T può essere derivata dalla classe V dove viene allocato un vettore di n posti. La classe V, genitrice, saràotata di un costruttore che inizializza il vettore e l'indice delle posizioni occupate, di un metodo print() per stampare il vettore e di un metodo set() per inserire un elemento nel vettore. La classe derivata T, può essere dotata soltanto di due metodi getpila() e getcoda(); che permettono di estrarre i dati secondo la modalitàella pila oppure quello della coda . Soluzione
Realizza la classe Q (Quadrato) dotata degli attributi lato, posx e posy; questi ultimi due sono le coordinate cartesiane dell'angolo superiore sinistro del quadrato. L'oggetto di classe Q può essere istanziato solo tramite costruttore. Realizza poi la classe I (insieme) che riceve in ingresso due quadrati e restituisce in uscita l'esito di una loro eventuale intersezione (sovrapposizione); in tal caso l'oggetto di classe I deve restituire l'area dell' intersezione e dell'unione dei due quadrati. (esempio di scambio di dati fra classi non derivate fra loro). Soluzione