1) Reprsenter la suite binaire dans les codes suivants :

2) Mme question :

3) Dessiner la sortie associe la suite binaire b=1001110100110101110 suivant le codage AMI : AMI : au premier 1 rencontr, on code par une tension positive. Pour chaque 1 suivant on code par la tension oppose. Les 0 sont cods avec la tension nulle.

4) Identifier et dcoder les signaux suivants :

class matrix { public: matrix(int d); matrix(int d1, int d2); ~matrix(); int ub1() const { return (s1 - 1); } int ub2() const { return (s2 - 1); } private: int** p; int s1, s2; }; matrix::matrix(int d): s1(d), s2(d) { if (d < 1) { // cerr is the standard stream for error output // similar to stderr in C cerr << "illegal matrix size" << d << "by" << d << "\n"; exit(1); } p = new int*[s1]; for (int i = 0; i < s1; i++) p[i] = new int[s2]; } matrix::matrix(int d1, int d2): s1(d1), s2(d2) { if (d1 < 1 || d2 < 1) { cerr << "illegal matrix size" << d1 << "by" << d2 << "\n"; exit(1); } p = new int*[s1]; for (int i = 0; i < s1; i++) p[i] = new int[s2]; } matrix::~matrix() { for (int i = 0; i <= ub1(); ++i) delete p[i]; delete []p; }

matrix add(const matrix& m1, const matrix& m2) { //check sizes assert((m1.s1 == m2.s1) && (m1.s2 == m2.s2)); //use privileged access to p in both classes matrix ans(m1.s1); int i, j; for (i = 0; i <= m1.ub2(); ++i) { for (j = 0; j <= m2.ub1(); ++j) ans.p[i][j] = m1.p[i][j] + m2.p[i][j]; } return ans; } matrix matrix::add(const matrix& m) {

//check sizes assert((s1 == m.s1) && (s2 == m.s2)); //use privileged access to p in both classes matrix ans(s1); int i, j; for (i = 0; i <= s2; ++i) { for (j = 0; j <= s1; ++j) ans.p[i][j] = p[i][j] + m.p[i][j]; } return ans; } /*Since addition is a symmetrical binary operation, it seems more appropriate to overload it with the friend function. On the other hand, since this operation is always applied to two matrices, having the second function allows one to use the code: a_matrix.add(another_matrix)*/ --------------------------------class matrix; class vect { public: friend vect ..... private: int* p; int size; }; //forward reference

mpy(const vect& v, const matrix& m);

class matrix { public: friend vect mpy(const vect& v, const matrix& m); ..... private: int** p; int s1, s2; }; vect mpy(const vect& v, const matrix& m) { assert(v.size == m.s1); //check sizes //use privileged access to p in both classes vect ans(m.s2); int i, j; for (i = 0; i <= m.s2; ++i) { ans.p[i] = 0; for (j = 0; j <= m.s1(); ++j) ans.p[i] += v.p[j] * m.p[j][i]; } return ans; }

--------------------------------TP4 POO-----------------------------------------#include <iostream.h> #include <conio.h> // Classe vecteur // Fonction AMIE calculant le dterminant de 2 vecteurs class vecteur { private : float x,y; public: vecteur(float,float); void affiche(); friend float det(vecteur, vecteur); }; vecteur::vecteur(float abs =0.,float ord = 0.) {x=abs; y=ord;} void vecteur::affiche() {cout<<"x = "<< x << " y = "<< y << "\n";} float det(vecteur a, vecteur b) { // la fonction AMIE peut manipuler // les quantits b.x, b.y, a.x, a.y float res; res = a.x * b.y - a.y * b.x; return res; } void main() { vecteur u(2,6),v(4,8); u.affiche(); v.affiche(); cout <<"Dterminant de (u,v) = "<<det(u,v)<<"\n"; cout <<"Dterminant de (v,u) = "<<det(v,u)<<"\n"; getch() ; } -------------------------------------------------------------------------------

----------------------------------EXP2----------------------------------------#include<iostream> #include<conio.h> using namespace std; class bankaccount { int account; int balance ; char id[20]; char password[20]; public: bankaccount(int a,int b,char c[20], char d[20]) { account=a; balance=b; strcpy(id,c); strcpy(password,d); } int transfer() { int x; int amt,bal; cout<<"Enter the balance you want to transfer from the bank account :"; cin>>bal; x=strcmp(id,password); if(x==0) { amt=balance-bal; cout<<amt<<endl<<"You have successfully deducted the Amount with transfer"<<endl; } } friend int backdoorCall(bankaccount a, int b); }; int backdoorCall(bankaccount a, int l) { int m; m=a.balance-l; cout<<m<<endl<<"You have successfully deduct the Amount with backdoorCall"<<endl; } int main() { bankaccount a(15000,50000,"Xahra","Xahra"); backdoorCall(a,15000); getche(); return 0; } ----------------------------------------------------------------------------

class Point { protected: //accessible uniquement par hritage int X;intY; public : // accessible partout int GetX(void) {return X;} int GetY(void) {return Y;} Point (int NewX=0, intNewY=0) {X=NewX;Y=NewY;} }; class Pixel : public Point //drive de point, { protected: int couleur; public : Pixel (int nx,int ny,int coul=0); void allume(void); void allume(int couleur); //surcharge : on peut allumer avec une autre couleur void eteind(void); };

++++++++++++ Les accs drivs sont le plus restrictif entre celui dfini dans la classe de base et celui prcis lors de la drivation (ici drivation publique, les accs restent inchangs sauf pour les privs qui sont inaccessibles).
Pixel::Pixel(int nx,int ny,int coul):Point(nx,ny) // je prcise la //liste (spare par des virgules) des constructeurs //(sinon val par dfaut), je n'ai plus qu' construire les //ajouts par rapport la classe de base {couleur=coul;} void Pixel::allume(void) {g_pixel(X,Y,couleur);} //g_pixel : une fonction qui allume un pixel l'cran void Pixel::allume(int coul) {g_pixel(X,Y,couleur=coul);} void Pixel::eteind(void) {allume(0);}

+++++++++++++++++ On pourrait maintenant dfinir une classe segment contenant un pixel et un point (la couleur n'a besoin d'tre stocke qu'une fois). On redfinirait des mthodes de mme nom : Segment::allume...
-------------------------------------------------------------------------------

(i) Hritage multiple L'hritage multiple permet une classe d'hriter de plusieurs super-classes. Ceci permet d'intgrer dans la sous-classe plusieurs concept d'abstractions qui caractrisent cette sous-classe. Pour cela, il suffit de dclarer les super-classes les unes aprs les autres. Si une classe C hrite de A et de B, la syntaxe sera la suivante:
class C : ''type_hritage'' A, ''type_hritage'' B ''...'' { ''.......'' }; -------------------------------------------------------------------------------

class Personne { protected: // Membres protgs char nom; char adresse; public: // Membres publics adress = 0) {

// Constructeur Personne(char name, char adress = 0 }

// Retourne le nom de la personne const char getNom() const { return nom; } // Dfini le nom de la personne void setNom(const char name) { if(name) { nom = new char[strlen(name)]; strcpy(nom, name); } else nom = 0; } // Retourne l'adresse de la personne const char getAdresse() const { return adresse; } // Dfini l'adresse de la personne void setAdresse(const char * adress) { if(adress) { strcpy(adresse, adress); } else adresse = 0; }

};

Construction et destruction
A la construction d'une classe fille, le constructeur de la classe mre est appel avant tout autre chose. Tout comme pour la construction des attributs d'une classe, il est possible de spcifier lors de la dfinition du constructeur de la classe fille des paramtres au constructeur de la classe mre. Si l'on ne spcifie rien, le constructeur par dfaut de la classe mre est appel. Par exemple pour la classe Etudiant qui hrite de la classe Personne, il est ncessaire de spcifier un nom au constructeur de Personne car cette classe n'a pas de constructeur par dfaut. Voici la classe Etudiant :

class Etudiant { protected: double moyenne; public: // Constructeur qui appelle le constructeur de la classe Personne // Et qui initialise la moyenne Etudiant(double m, const char * name, const char * adress = 0) : Personne(name, adress), moyenne(m) {} // Constructeur de recopie // (on fait appel au constructeur de recopie de la classe Personne) Etudiant(const Etudiant & e) : Personne(e), moyenne(e.moyenne) {} // Oprateur d'affectation // Attention on fait un appel explicite la mthode // operator= de Personne Etudiant & operator=(const Etudiant & e) { this->Personne::operator=(e); moyenne = e.moyenne; } // Mthodes d'accs la moyenne double getMoyenne() const { return moyenne; } void setMoyenne(double m) { moyenne = m; }

}; int main() { Etudiant bob(15, "Bob Marley"); // bob hrite des mthodes de la classe Personne bob.setAdresse("Kingston, Jamaique"); }