Reponses Devoir 2

Exercice1:
1) Classe vectB:
// vect-B.h
#ifndef VECT_B_H
#define VECT_B_H

#include "vect.h"

class vect_B : public vect {

int lower_bound; // limite inférieure des indices
public:
vect_B(int lower, int upper);
int getLowerBound() const;
int getUpperBound() const;
~vect_B();
};

#endif // VECT_B_H
// vect-B.cpp
#include "vect-B.h"

vect_B::vect_B(int lower, int upper) : vect(upper - lower + 1),

lower_bound(lower) {}
int vect_B::getLowerBound() const {
return lower_bound;
}

int vect_B::getUpperBound() const {

return lower_bound + nelem - 1;
}

vect_B::~vect_B() {
// Destructor implementation if needed
}
2) // vect-C.h
#ifndef VECT_C_H
#define VECT_C_H

#include "vect.h"

class vect_C : public vect {

public:
vect_C(int size);
vect_C(const vect_C& other); // Constructeur par recopie
vect_C& operator=(const vect_C& other); // Surcharge de
l'opérateur d'affectation
int taille() const; // Fonction membre pour obtenir la taille du
vecteur
 ~vect_C();
};

#endif // VECT_C_H
Exercice3:
1) // vect_dyn.h
#ifndef VECT_DYN_H
#define VECT_DYN_H

template <typename T>

class vect_dyn {
private:
int nelem; // nombre d'éléments
T* adr; // adresse zone dynamique contenant les éléments

public:
vect_dyn(int size);
~vect_dyn();

T& operator[](int index);

};

template <typename T>

vect_dyn<T>::vect_dyn(int size) : nelem(size), adr(new T[size]) {}
template <typename T>
vect_dyn<T>::~vect_dyn() {
delete[] adr;
}

template <typename T>

T& vect_dyn<T>::operator[](int index) {
// Vérification de l'indice pour éviter le débordement
if (index < 0 || index >= nelem) {
// Gérer l'erreur, lancer une exception, ou prendre une action
appropriée
// Pour cet exemple, on lance une exception std::out_of_range
throw std::out_of_range("Index out of range");
}
return adr[index];
}

#endif // VECT_DYN_H
2) // vect_dim.h
#ifndef VECT_DIM_H
#define VECT_DIM_H

template <typename T, int Dimension>

class vect_dim {
private:
 T adr[Dimension]; // adresse statique contenant les éléments

public:
vect_dim();
~vect_dim();

T& operator[](int index);

};

template <typename T, int Dimension>

vect_dim<T, Dimension>::vect_dim() {}

template <typename T, int Dimension>

vect_dim<T, Dimension>::~vect_dim() {}

template <typename T, int Dimension>

T& vect_dim<T, Dimension>::operator[](int index) {
// Vérification de l'indice pour éviter le débordement
if (index < 0 || index >= Dimension) {
// Gérer l'erreur, lancer une exception, ou prendre une action
appropriée
// Pour cet exemple, on lance une exception std::out_of_range
throw std::out_of_range("Index out of range");
}
return adr[index];
}

#endif // VECT_DIM_H
Exercice4:
1) I- #include <iostream>

template <class T>

class point {
T x, y; // coordonnees
public:
point(T abs, T ord) : x(abs), y(ord) {}

void affiche() {
std::cout << "Coordonnees : " << x << " " << y << "\n";
}
};

template <class T>

class pointcol : public point<T> {
T couleur; // couleur
public:
pointcol(T abs, T ord, T col) : point<T>(abs, ord), couleur(col) {}

void affiche() {
point<T>::affiche();
 std::cout << "Couleur : " << couleur << "\n";
}
};
II. #include <iostream>

template <class CoordType, class ColorType>

class pointcol {
CoordType x, y; // coordonnees
ColorType couleur; // couleur
public:
pointcol(CoordType abs, CoordType ord, ColorType col) :
x(abs), y(ord), couleur(col) {}

void affiche() {
std::cout << "Coordonnees : " << x << " " << y << "\n";
std::cout << "Couleur : " << couleur << "\n";
}
};
III. #include <iostream>

class point_ordinaire {
int x, y; // coordonnees
short couleur; // couleur
public:
 point_ordinaire(int abs, int ord, short col) : x(abs), y(ord),
couleur(col) {}

void affiche() {
std::cout << "Coordonnees : " << x << " " << y << "\n";
std::cout << "Couleur : " << couleur << "\n";
}
};
2). I. #include <iostream>

template <class T>

class point {
T x, y; // coordonnees
public:
point(T abs, T ord) : x(abs), y(ord) {}

void affiche() {
std::cout << "Coordonnees : " << x << " " << y << "\n";
}
};

// Version spécialisée de affiche pour le cas où T est le type

caractère
template <>
void point<char>::affiche() {
 std::cout << "Coordonnees : " << x << " " << y << "\n";
std::cout << "Caractere : " << x << "\n";
}
II. #include <iostream>

template <class T>

class point {
T x, y; // coordonnees
public:
point(T abs, T ord) : x(abs), y(ord) {}

void affiche() {
std::cout << "Coordonnees : " << x << " " << y << "\n";
}
};

template <class T>

class pointcol : public point<T> {
T couleur; // couleur
public:
pointcol(T abs, T ord, T col) : point<T>(abs, ord), couleur(col) {}

void affiche() {
point<T>::affiche();
std::cout << "Couleur : " << couleur << "\n";
 }
};

// Version spécialisée de affiche pour le cas où T est le type

caractère
template <>
void pointcol<char>::affiche() {
std::cout << "Coordonnees : " << x << " " << y << "\n";
std::cout << "Caractere : " << couleur << "\n";
}