C C++

#include <stdio.h> #include <iostream.h>

Fonction <printf coût. dans sont des objets
Scanf cout << "Bonjour";
Opérateur d'insertion
Ou
Insérateurs
cout << "valeur =" << a;
Pas besoin de spécificateurs de format.
En C++

Scanf ( "%d", &a); cin >>a;

Opérateur d'extraction
Ou
Extracteur
cin >>a >>b;
Cascading des extracteurs;

pour la ligne suivante

Printf ( "Bonjour \n utilisateur"); cout << "Bonjour \n Utilisateur";
Ou
cout << "Bonjour" << end << "Utilisateur";

En C, le type de retour par défaut en C++ valeur de retour par défaut

vide le type est un "entier"

HISTOIRE DE C++

Année 1982
Développé Bjarne Stroustrup
Laboratoire Bell Labs
Entreprise At & T

C est un langage orienté procédure C est un langage orienté objet

Programmation facile et rapide en C++ modèle étroitement le monde réel

C. Les logiques peuvent être facilement développées Problèmes développés.
 CLASSES ET OBJETS
Dans une structure en C :- seules les données peuvent être membres de la structure et non des fonctions.
Tous les membres de la structure sont publics par défaut
Dans une classe, les données C++ et les fonctions accédant à ces données sont membres de la classe et tout
Les membres de la classe sont privés par défaut

classe étudiant
{
int rouler;
char note;
flottant par;
public :
void get( );
void montrer( );
};
void stud :: obtenir()
{
cout << "entrez le numéro. Note et pourcentage";
cin >> roll >> grade >> per;
}
void stud : : afficher
{
cout <<roll << " "<< grade << " " <<per<< end1;
}

void main( ) rouler

{ obtenir
soudes
s. obtenir ( ); s montrer note
s. afficher( );
}
Par

Les fonctions ne sont jamais dupliquées, il n'y a qu'une seule copie de la fonction, peu importe quoi.
de nombreux objets ne sont créés qu'une seule fois, la mémoire est allouée aux fonctions pour tous les objets
où plusieurs copies de données sont créées pour plusieurs objets.
L'opérateur de résolution de portée aide le compilateur à identifier les fonctions de quelle classe si
deux classes ont le même nom.

Q. 1 wap pour additionner deux nombres donnés par l'utilisateur

classe ajouter
{
int a, b, c;
public :
void obtenir( );
void somme();
void show( );
};
void ajouter : : obtenir ( )
{
cout << "Entrez le numéro";
cin >> a >> b;
}
vide ajouter : : somme( )
{
c= a+b;
}
void ajouter : : afficher( )
{
cout << "Les nombres sont = " << a << " " << b;
cout << "somme =" << c;
}
void main( )
{
ajouter un objet;

obj. get( );
[Link]( );
obj. afficher( );
getch( );
}
C++ (Terminologie) Poo (Terminologie)
objets instances
2. membres de données propriétés et attributs
3. fonction membre méthodes et comportements
4. appel de fonction passage de messages

PRINCIPES FONDAMENTAUX DE LA POO

ENCAPSULATION
Le mot a été dérivé d'un mot capsule qui signifie multiple
médicaments emballés dans une seule unité. De même, dans un logiciel, il y a deux principaux
données d'unité et fonctions agissant sur ces données puisque les fonctions et les données sont liées
Il est conseillé de les noter au sein d'une seule unité. Ainsi, selon le OOP.
L'encapsulation signifie construire ou regrouper des membres de données etnagir sur
ces membres de données au sein d'une seule unité. Puisqu'une classe nous permet de maintenir des données &
les fonctions à l'intérieur disent qu'elles soutiennent le principe d'encapsulation.

POLYMORPHISME
Le mot polymorphisme est dérivé de la combinaison de deux mots
poly signifie multiple et morph veut dire la capacité d'avoir plusieurs formes. Dans
d'autres mots si une entité peut acquérir plusieurs formes dans différentes situations, nous disons
que ses comportements sont polymorphes, par exemple en C++, il est possible pour le programmeur de
redéfinir l'opérateur '+' de manière à ce qu'il puisse être utilisé pour additionner deux entiers ainsi que
En même temps, cela peut ajouter deux objets ou deux chaînes. Donc, un programmeur définit +.
pour se comporter dans le membre mentionné ci-dessus, nous disons que + se comporte de manière polymorphe.
En C++, le polymorphisme est implémenté de deux manières :

(1). Polymorphisme à temps de compilation : surcharge de fonction et opérateur

Surcharge
(ii). Polymorphisme d'exécution : fonctions virtuelles, fonctions virtuelles pures
Classes abstraites
(iii). Héritage : - hériter signifie acquérir des propriétés et des caractéristiques d'un
Entité existante dans une entité nouvellement créée Comme un
L'enfant acquiert les propriétés de son parent, de la même manière que lors de la conception.
logiciel si un programmeur le souhaite alors il peut acquérir les caractéristiques (données et
fonction membre) d'une classe existante dans sa propre classe avec l'aide de
héritage. La classe qui est héritée est connue sous le nom de classe de base et le
classe. Ainsi, en héritant des membres de la classe de base, il devient possible de
accédez-les via les objets de la classe dérivée. Le principal avantage offert
par le principe d'héritage est « réutilisabilité et fiabilité »
CRÉER DES FONCTIONS PARAMÉTRÉES DANS DES CLASSES

classe Emp
{
int âge;
char name[20];
salaire flottant;
public
void set (int, char *, float);
void afficher()
};
void Emp::set(int I, char *j, float K)
{
I
strcpy(nom, j);
salaire = k;
}
void Emp : : montrer( )
{
cout << âge << " " << nom << " " << salaire;
}

DEVOIR
Wap pour créer une classe c/a chaîne. La classe doit contenir un caractère
tableau de taille 20. la classe devrait avoir les fonctions suivantes :

(1).ObtenirChaine( ) qui accepte une chaîne comme paramètre + la stocke dans le tableau str.
(2). Afficher chaîne( ) qui affiche la chaîne stockée dans str[].
(3).Inversechaine ( ) qui inverse la chaîne stockée dans str[].
(4). Ajouter la chaîne() qui accepte une chaîne en tant que paramètre et si possible
Concatène dans str.

Écrivez un programme orienté objet pour calculer la factorielle d'un nombre donné par l'utilisateur.
Fournir une fonction séparée pour l'initialisation, l'entrée, le calcul et l'affichage.

classe Fait
{
 long int f;
int n;
public:
vide init( );
void getno();
void calculer( );
void display( );
};
void Fact :: init()
{
f=1;
}
void Fact :: obtenirno()
{
cout << "Entrez un nombre";
cin >> n;
}
void Fact : : calculer( )
{
int i;
pour (i=1; i<=n; i++)
f=f * i;
}
void Fact : : afficher( )
{
cout << " Nombre =" << n;
cout << "factoriel=" << f;
}
vidé principal( )
{
Fait obj ;
obj. init( );
[Link]( );
[Link] calculer( );
obj. afficher();
}

CONSTRUCTEUR
Constructeur : - les constructeurs sont des membres spéciauxnd'une classe avec les éléments suivants
propriétés

Ils ont le même nom que celui de la classe

[Link] n'ont aucun type de retour, pas même void.
[Link] sont automatiquement appelés dès que l'objet de la classe est créé, c'est-à-dire leur
l'appel est implicite.
Ils ne peuvent pas être déclarés comme statiques
5. Ils ne peuvent pas être déclarés comme virtuels

Toute classe qui ne contient pas de constructeur sera générée par le compilateur lui-même.
le fournisseur est un constructeur mais il est caché. pour le programmeur, ces constructeurs sont
par défaut

classe fait
{

}
Les constructeurs sont appelés automatiquement même lorsqu'ils ne sont pas déclarés, à ce moment-là.
Les constructeurs par défaut sont appelés. Les constructeurs par défaut sont détruits dès que nous
déclarer le constructeur

Exemple :-
classe fait
{
int n;
long int f;
public
fait( )
{
f=1;
}
void getno( );
void calculer( );
void afficher( );
};
void fact : : getno( )
{
cout << "entrez un numéro";
an >> n;
}
void fact : : calculer( )
{
int i;
pour (i=1; i<=n; i++)
f = f * i;
}
vide fait : : afficher ( )
{
cout << "no=" << n << end1;
cout << "factorielle=" << f;
}
void main( )
{
fait obj;
[Link]( );
[Link]( );
[Link]( );
}

CONSTRUCTEUR PARAMÉTRÉ

classe Emp
{
int âge;
char nom[20];
flottant sal;
public :
Emp (int, char *, float);
void montrer( );
};
Emp : : Emp (int i, char *j, float k)
{
i
strcpy (nom, j);
k
}
void Emp : : montrer( )
{
cout << âge << " " << nom << ' ' << sal;
 }

void main()
{
Emp e(101, "Amit", 6000.00) ;
[Link]( );
getch( );
}

SURCHARGE DE FONCTION
void show (int, int, int)
1. Nombre d'arguments void afficher (int)
2. Type d'argument void montrer (double)
3. Ordre des arguments void afficher (int, double)
void show (double, int)

int afficher ( )
Non autorisé (le type de retour diffère)
void afficher()

Le compilateur ne prend pas en compte le type de retour, sinon le constructeur ne pourrait jamais être
surchargé car ils n'ont pas de type de retour. La surcharge de fonction permet à certains
nom de la fonction dans le même scope mais il doit y avoir des différences entre les fonctions.

void vol (int);

void vol (int, int, int );
void main ( )
{
int choix;
cout << "sélectionnez une figure";
cout << " (1) cube \n (2) cuboïde";
cin >> choix;
Interrupteur (choix)
{
cas 1 :
int s;
cout << "entrez la côté du cube";
cin >> s;
vol (s);
pause;
 cas 2 :
int l, b, h;
cout << "Entrez les valeurs l, b et h";
cin >> l >> b >> h;
vol (l, b, h);
pause;
default
cout << "choix incorrect";
}
void vol (int s)
{
cout << "valeur du cube =" << s*s*s;
}
vide vol (int l, int b, int h)
{
cout << "valeur du placard=" << l*b*h;
}

AVANTAGES DE LA Surcharge de Fonction

1. La surcharge de se souvenir du nom se transforme de programmeur en

compilateur
Cela développe la symétrie et augmente la lisibilité du programme

Surcharge de constructeur

classe Boîte
{
int l, b, h;
public
Box( ); //constructeur pour la boîte définie par l'utilisateur
Boîte (int); //constructeur pour
Boîte(int,int,int);
void show( );
};
Boîte : : Boîte( )
{
cout << "entrez l, b et h de la boîte";
cin >> l >> b >> h;
}
Boîte : : Boîte(int s)
{
l=b=h=s;
}
Boîte : : Boîte (int i, int j, int k)
{
l=i;
b=j;
h=k;
}
void Box :: montrer( )
{
cout << l << " " << b << " " << h;
}
void main ( )
{
Boîte B1;
Boîte B2 (5,7,11);
Boîte B3 (10);
B1. montrer( );
B2. afficher ( );
B3. afficher ( );
}

CONSTRUCTEUR DE COPIE

C'est un constructeur spécial d'une classe qui accepte la référence de l'objet de celui-ci.
notre classe comme paramètre. Il est appelé par le compilateur C++ dans ces situations

1. chaque fois qu'un programmeur crée un objet et passe en même temps un autre
objet de la même classe en tant que paramètre
[Link] les fois que af
n
accepte un objet comme paramètre par valeur.
3. chaque fois qu'un f
n
renvoie un objet par valeur.

Variable de référence : -

Syntaxe :- <type de données> & <nom-sef> = <nom-var> ;

void main() dos des pointeurs

{ occuper 2 octets de mémoire
int a = 10; 2. sera initialisé par des déchets
int *p; 3. nécessaire de les initialiser avant leur utilisation
p=&a;
cout <<*p <<end1; 4. très prudent dans l'utilisation de l'opérateur d'indirection
}

void main ( ) Avantage de la variable de référence

{
int a=10; Nous pouvons avoir n variables de référence d'un
int &p=a; variable
cout << a << " " << p;
cout << &a << " " << &p; 2. les deux variables s'entrelacent à chaque
Autre
3. ne nécessite aucun espace mémoire
Réutilisez uniquement la mémoire de toute variable

La variable de référence est une technologie fournie par C++ qui permet à un programmeur de
créez une nouvelle variable qui stocke (ne conserve pas) l'emplacement mémoire d'une existante
variable. En d'autres termes, la variable de référence est une technique utilisée par le programmeur
peut attribuer plusieurs noms au même emplacement mémoire.

POINTE À SE SOUVENIR
int &p = a;
[Link] &p =b;
déclarations multiples pour la variable p.
3. En cas de tableau, utilisez toujours un pointeur. Une variable de référence ne peut pas fonctionner avec
tableau
4. nous ne pouvons pas créer un tableau de variables de référence

int &p [4]

 C C C++

passer par valeur passer par référence passer par référence

void échanger (int, int); void échanger (int*, int*); void échanger (int&, int&);
void main() void main( ) void main()
{ { {
int a,b; int a,b; int a,b;
cout << "Entrez2 numéro"; cout << "Entrez2 non"; clrscr() ;
cin >>a>>b; cin >> a >> b;
échanger (a,b); échanger (&a, &b) cout << "entrer2no")
cout << a << " " << b; cout << a << " " << b; cin>>a>>b;
} } échanger (a,b);
void échanger(int p, int q) void échanger (int*p, int*q) cout <<a<< “ “<<b;
{ {
int temp; int temp; }
temp =p; temp=*p; void swap(int&p,int&q)
p=q; *p=*q; {
q=temp; *q= temp; int temp;
} } temp=p;
p=q;
q=temp;
}

Remarque : Par appel, il n'est pas possible de déterminer s'il s'agit d'un appel par valeur ou d'un appel par référence.

référence

Q. Écrivez un programme pour utiliser un appel de fonction maximum qui accepte un tableau d'entiers de taille
pur comme un argument et renvoie le plus grand et le plus petit élément de ce tableau à main.
Sans changer la position d'origine des éléments du tableau.

void Maximum (int a[], int &, int&)

void main( )
{
int a[5], i, grand, petit;
pour (i=0; i<5; i++)
{
cout << "entrez les éléments du tableau";
 cin >>a[i];
}
Maximum (a, grand, petit);
cout << "élément maximum=" << large;
cout << "élément plus petit=" << small;
}
void Maximum (int a[5], int &max, int &min)
{
max = a[0];
min=a[0];
pour(int i=1; i<5; i++)
{
si (*(a+i) >max)
max=* (a+i);
sinon si (*(a+i) < min)
min = *(a+i);
}
}

classe Boîte
{
int l, b, h;
public :
Boîte( );
Boîte (int);
Boîte (int, int, int);
Boîte (Boîte &);
void afficher( );
};
Boîte : : Boîte()
{
cout << "entrez l, b et h de la boîte";
cin >> l >> b >> h;
}
Boîte : : Boîte (int S)
{
l=b=h=s;
}
Boîte : : Boîte (Boîte &p)
{
 l=p.l;
b=p.b;
h=p.h;
}
Box : : Box (int i, int j, int k)
{
l=i;
b=j;
h=k;
}
void Box:: montrer()
{
cout << l << " " << b << " " << h;
}
void main ( )
{
Boîte B1;
Boîte B2 (10);
Boîte B2 (5,7,11);
Boîte B4 (B1);
B1. montrer( );
[Link]();
[Link]( );
[Link]( );
}

Boîte B2 (10) Box B2 = 10;

Boîte B4 (B1) Boîte B4 = B;
Appel au constructeur de copie

Boîte B4;
B1
Pas d'appel au constructeur de copie, utilisation de l'opérateur d'assignation autre
l'objet de destination est déjà créé.

ARGUMENTS PAR DÉFAUT

void printline (char ='*', int=1);

vide principal ( )
{
 imprimerligne ( ); // imprimerligne ('*', 1)
imprimerligne ('#'); // printline ( ' # ', 1)
imprimerligne ('!', 10) // imprimerligne ('!', 10);
}
void imprimerligne (char ch, int n)
{
pour (int i=1 i<=n; i++)
cout <<ch;
}

Remarque : les arguments par défaut doivent toujours être des arguments finaux.

printline(50); imprimerligne (ASCII de 50, 1);

classe Étudiant
{
int âge;
char note;
flottant per;
public :
Étudiant (int, char, float); // étudiant (int=o, char= ' ; float=0.0);
void obtenir( );
vide montrer( );
};
Stud : : Stud (int I, char j, float k)
{
I
j
per =k;
}
void Étudiant:: obtenir()
{
cout << "Entrez l'âge, la note et le pourcent";
cin >> âge >> note >> pour;
}
void Étud : : afficher( )
{
cout << " âge = " << âge << " \n note = " << note << " \n per = <<per;
}
vide principal()
{
 Étudiant t ( 15, ‘A’, 75);
Stud p;
p. obtenir( );
t. afficher( );
p. montrer( );
}

Remarque : Dans une classe, il n'est pas possible d'avoir un constructeur par défaut en même temps.
et constructeur par défaut.

DESCTRUCTEUR
Sont des membres spéciaux fnde la classe qui porte le même nom que celui de la classe mais
précédé du symbole de champ (). Ils sont automatiquement appelés chaque fois qu'un
l'objet sort de la portée et est sur le point d'être détruit

Lorsque un objet est créé, la première fonction qui est automatiquement appelée est
le constructeur et lorsque l'objet termine sa vie, une dernière fonction est appelée pour libérer l'occupation
la mémoire est un destructeur

classe Emp
{
int âge;
char nom [20];
flottant sal;
public
Emp( );
~Emp( );
vide montrer( );
};
Emp : : Emp( )
{
cout << "Entrez l'âge, le nom et le salaire";
cin >> âge >> nom >> salaire;
}
void Emp:: montrer() Remarque
{ Une classe a par défaut 3 intégrés
cout <<age << "nom <<sal; fonction
} 1. Constructeur
Emp : :~ Emp( ) 2. constructeur de copie
{ 3. Destructeur
std::cout << "Objet détruit";
} Remarque : Les destructeurs sont toujours appelés dans
void main() ordre inverse.
{
Emp e, f,;
e. afficher( );
f. montrer( );
}

Créer une classe c/o étudiant ayant 3 membres de données (i) pour stocker le numéro de rôle. (ii) pour
stockage du nom (iii) pour le stockage des notes dans les matières

Le membre pour stocker le nom devrait être char *, le membre pour stocker les notes devrait
sois int *;

Créez un constructeur de classe qui invite l'utilisateur à entrer la longueur du nom.

alloue une mémoire suffisante et accepte le nom de l'utilisateur. Le même constructeur
demande à l'utilisateur combien de sujets il souhaite saisir, réalloue à nouveau une mémoire suffisante
pour cela & accepte les notes données par l'utilisateur. Fournissez finalement une fonction membre appropriée.n
qui affiche % et note de l'étudiant. À la fin, définissez le destructeur correctement.
manière de désallouer la mémoire allouée par le constructeur.

classe étudiant
{
int lancer, n;
char * nom, note;
int *notes;
flotte par;
public :
étudiant ( );
void get();
vide calculer( );
void show( );
~étudiant( );
}

étudiant
{
cout << "combien de lettres";
 cin >> n;
name = (char *) malloc ((n+1) * sizeof (char));
si (nom == NULL)
exit(1);
obtenir( );
}
vide étudiant : : obtenir( )
{
cout << " entrez le numéro de rôle";
cin >> roll ;
cout << "entrez votre nom";
cin >> nom;
cout << "combien de matières y a-t-il entre ";
cin >>n;
marks=(int*)malloc(n*2);
pour (i=0; i<n; i++)
{
cout << "Entrez les notes";
cin >> * (notes+i);
}
}

void étudiant : : calculer ( )

{
per=0;
pour (int i=0; i<n; i++)
per+= * (notes+i)
per =per/n;
si (per >=75)
A
sinon si (per >=60)
B
sinon
f
}
étudiant : :~ étudiant ( )
{
libre (nom);
libérer(marques);
}
void étudiant :: montrer( )
{
cout << " Nom = " << nom << "\n numéro de rouleau = " << rouleau;
cout << " per=" << per << " \n grade=" << grade;
pour(int i=0;i<n;i++)
cout << " " << marks[i];
}
vide principal()
{
étudiant s;
s. calculer( );
s. montrer( );
}
Note En C++, cin n'accepte pas l'espace
void main( )
{
char str[20];
cout << "entrez le nom";
cin >> str;
}
[Link] (str, 80); //Touche Entrée /9.

Prototype de get line ()

void get line (char *, int );
Membre du fichier d'en-tête istream

COMPARAISON ENTRE
CONSTRUCTEUR & DESTRUCTEUR

CONSTRUCTEUR
n
[Link] des membres spéciaux f d'une classe ayant le même nom que la classe.
2. Les constructeurs sont automatiquement appelés dès qu'un objet de la classe est créé c'est-à-dire.
leur appel est implicite
3. les constructeurs peuvent être paramétrés.
4. puisque les constructeurs acceptent des paramètres, ils peuvent être surchargés et donc une classe
peut avoir plusieurs constructeurs.
Les constructeurs sont appelés dans l'ordre dans lequel les objets sont créés.
6. Les constructeurs ne peuvent pas être hérités.
7. Les constructeurs ne peuvent pas être déclarés comme virtuels.
DEStructeur
n
[Link] des membres spéciaux f de la classe ayant le même nom que celui de la classe mais
précédé du symbole de tilde
2. un destructeur est également appelé automatiquement chaque fois qu'un objet est sur le point d'être
le destructeur ou sort de la portée, donc ces appels sont implicites.
3. nous ne pouvons pas passer des paramètres à un destructeur.
4. Comme ils n'acceptent pas de paramètres, nous ne pouvons pas les surcharger, donc une classe ne peut pas.

avoir plusieurs destructeurs

5. l'appel du destructeur se fait toujours dans l'ordre inverse de la création des objets.
6. l'héritage du destructeur n'est également pas possible
7. nous pouvons avoir un destructeur virtuel dans une classe.

FONCTIONS EN LIGNE

Fonctions inline
Sont-ils fndont l'appel est remplacé par leur corps pendant
compilation. Déclarer un fnen ligne a deux avantages majeurs.

1. Le compilateur ne doit pas quitter l'appelant fncomme il trouve la définition de fnêtre

s'appelaient eux-mêmes.
2. Le coût d'entretien de la pile dans l'appel de la fonction belureen est réduit
Ainsi, déclarer une fonction comme inline augmente l'exécution
La vitesse, le temps d'exécution des ressources et donc améliore l'efficacité globale du programme.
Mais deux pointeurs doivent être considérés avant de déclarer une [Link] ligne

[Link] définition de la fonction inline doit apparaître avant son appel c'est-à-dire si un non
membre fndoit être fait en ligne alors sa déclaration et sa définition doivent apparaître
à propos de principal en tant qu'unité unique.
[Link] corps de f en lignendoit
être court et petit
3. il ne devrait contenir aucun mot-clé complexe ou déclaration comme pour,
si, tandis que, faire tant que, faire
si l'une des règles ci-dessus est violée, alors le compilateur ignorera le
le mot clé en ligne traite du fncomme hors ligne ou normal. De plus, un
une classe peut avoir deux types de fonctions inline

1. Inline implicite :- fndéfini dans le corps de la classe

2. En ligne explicite : - fndéclaré
dans la classe mais défini en dehors de la classe
précédé par le mot clé en ligne.

Ainsi, à la fin, nous pouvons dire que déclarer un fncomme ligne est une demande
fait par le programmeur qui peut ensuite accepter ou refuser.

classe Emp
{
char nom [20];
int âge;
flotte sal;
public :
vide obtenir( )
Implicite {
En ligne cout << "entrez l'âge, le nom et le salaire";
cin >> âge >> nom >> salaire;
}
void afficher( );
};

Explicite inline void Emp:: afficher()

En ligne {
cout << âge << " " << nom << " " << salaire;
}

void main( )
{
Emp E[5];
int i
pour (i=0; i<5; i++)
E[i]. obtenir( );
pour (i=0; i<5; i++)
E[i] afficher( );
}

CLASSES DE STOCKAGE

La classe de stockage décide les éléments suivants

1. Valeur par défaut

 vie (persistance)
3. portée (accessibilité)

stockage par défaut vie portée

[Link] déchets limité à limité au bloc de déclaration
(automatique) leur
Déclaration
Bloc
2. statique Zéro tout au long “
Le programme
3. enregistrer les déchets identique à l'auto identique à l'auto
4. mondial zéro tout au long tout au long du programme
Le programme

Auto Statique
void afficher ( ); void afficher ( );
void main( ) vide principal()
{ {
afficher( ); afficher( );
afficher ( ); afficher ( );
afficher ( ); afficher( );
} }
void afficher( ) void afficher()
{ {
int a;
cout <<a<<end1; static int a;
a++; cout <<a<<end1;
} a++;
}
o/p 3 valeurs de déchet seront o/p 0
généré 1
2

DONNÉES STATIQUES
Membres de données statiques dans la classe
classe données
{
int a ;
int static b;
}; 0 b

a a
int données : : b;
d1 D2

les variables statiques n'attendent pas la création de l'objet, avant la création de l'objet, la mémoire est
alloué pour alors
de la classe
1. Un membre de données statique a une seule copie partagée entre chaque objet de cela
classe. D'autre part, si une classe a des données non statiques, alors chaque objet de celle-ci
la classe a sa propre copie de données non statiques
2. les membres de données statiques arrivent en mémoire même avant que les objets de la classe n'arrivent
créé. À cause de leur fonctionnalité, il devient nécessaire de les redéfinir à l'extérieur
la classe afin qu'ils puissent obtenir de l'espace dans la RAM sans l'aide d'un objet.
3. puisqu'ils ne sont liés à aucun objet particulier de la classe et ont un seul
copier dans toute la classe, un membre de données statiques ne contribue jamais à la taille de
Objet. En d'autres termes, la taille d'un objet est toujours calculée en additionnant les tailles.
des membres non statiques.
WAP pour créer une classe c/o étudiant ayant deux membres de données : roll et count.
le registre des membres doit conserver le numéro d'inscription attribué à chaque objet étudiant tandis que le
le nombre de membres doit suivre le nombre total d'objets d'étudiants actuellement dans le
mémoire. Enfin, fournir les membres appropriés fninitialiser et afficher les valeurs
de numéro de rouleau et de compte.

classe Étudiant
{
int lancer;
static int compteur;
public :
Étudiant (int i)
{
i;
++ compter ;
}
 imprimerligne ( ); // imprimerligne ('*', 1)
imprimerligne ('#'); // printline ( ' # ', 1)
imprimerligne ('!', 10) // imprimerligne ('!', 10);
}
void imprimerligne (char ch, int n)
{
pour (int i=1 i<=n; i++)
cout <<ch;
}

Remarque : les arguments par défaut doivent toujours être des arguments finaux.

printline(50); imprimerligne (ASCII de 50, 1);

classe Étudiant
{
int âge;
char note;
flottant per;
public :
Étudiant (int, char, float); // étudiant (int=o, char= ' ; float=0.0);
void obtenir( );
vide montrer( );

Stud : : Stud (int I, char j, float k)

{
I
j
per =k;
}
void Étudiant:: obtenir()
{
cout << "Entrez l'âge, la note et le pourcent";
cin >> âge >> note >> pour;
}
void Étud : : afficher( )
{
cout << " âge = " << âge << " \n note = " << note << " \n per = <<per;
}
vide principal()
{
{
int rouler;
static int count;
public :
étudiant (int i)
{
i;
++compte;
}
vide afficher()
{
cout << roll;

}
static void total_etudiant()
{
cout << "total d'objets vivants =" << count;
}
~étudiant ( )
{
--compte;
}
};
int étudiant : : compter;
vide principal()
{
étudiant S(10). P(20), Q(30);
[Link]();
[Link]();
[Link]();
étudiant
{
student X(40), Y(50);
X. montrer( );
[Link]();
étudiant::total_étudiant();
}
étudiant::total_étudiant();

}
 étudiant::total_étudiant();
getch( );
}

Créer une classe c/a employé ayant des membres de données pour stocker l'âge, le nom
& id. Fournissez également un autre membre qui stocke le prochain id qui sera
attribué au prochain objet entrant. Fournir un membrenpour initialiser cette variable
avec sa valeur initiale & fournir également le constructeur approprié & membre fnpour
tous les autres membres de la classe initialisés.

classe Emp
{
int âge;
char nom [20];
int id;
static int nid;
public
static void init()
{
nid
}
Emp( )
{
cout << "entrez l'âge, le nom";
cin >> âge >> nom;
nid
++nid;
}
void afficher( )
{
cout << âge << nom << id;
}
};

Solution :-

classe Employé
{
int âge;
 char nom[20];
int id;
int static nextid;
public :
Employé (int, char *);
static void initid( );
void afficher( );
static void getnextid();
~Employé( );
};

int Employé :: prochainId;

Employé : : Employé (int I, char * j)
{
Moi
strcpy (nom,j);
id = nextid++;
}
void Employé : : initid( )
{
1;
}
void Employé :: afficher( )
{
cout << age << " " << name << " " << id << end1;
}
void Employe:: getnextid()
{
cout << "le prochain employé recevra l'identifiant=" <<nextid;
}
Employé : : ~Employé( )
{
--nextid;
}
vide principal()
{
Employé : : initid( );
Employé : : obteniridsuivant( );
{
Employee e (25, “Rahul”);
 Employee f (30, “vipin”);
e. montrer( );
f. montrer( );
Employé : : obtenirleprochainsid( );
}
Employé : : obteniridsuivant( );
}

ce pointeur

classe Emp
{
int âge;
char nom[20];
flottant sal;
public :
void obtenir()
{
cout << "entrez l'âge, le nom et le salaire";
cin >> âge >> nom >> sal;
cout << "Adresse de l'objet appelant =" << this;
}
void show( )
{
cout <<âge<<nom<<salaire;
cout << "Adresse de l'objet appelant=" << this;
}
};
void main( )
{
Emp E, F;
[Link]( );
[Link]( );
[Link]( );
[Link]();
 }

[Link] membre fn de la classe a ce pointeur.

2. Pas besoin de déclarer et d'initialiser ce pointeur. Le compilateur l'initialise avec la base.
adresse de l'objet appelant.

ce pointeur
Ceci est un pointeur spécial disponible dans chaque fondation membre d'une classe, sauf
membre statique fnd'une classe. Chaque fois que l'objet d'une classe fait appel à une fonction non
membre statique fnde cette classe, le pointeur this disponible dans ce membre fn
commence implicitement à pointer vers l'adresse de l'objet appelant. Ainsi, nous pouvons dire qu'un
Le pointeur "this" pointe toujours ou fait référence à l'objet courant.

Par défaut, une classe a 3 pointeurs 'this'.

Constructeur, constructeur de copie, destructeur

Accéder aux membres de données en utilisant 'this'

classe Boîte
{
int l, b, h;
public
Boîte( );
Boîte (int, int, int);
Boîte (Boîte &);
void afficher( );
};
Boîte : : Boîte()
{
cout << "Entrez l, b et h";
cin >> l >> b >> h;
}
Boîte : : Boîte (int I, int j, int k)
{
l=i;/* peut également être écrit ainsi l=l;
 b=j; ceci b=b;
h=k; ceci h=h;*/

Boîte : : Boîte (Boîte &p)

{
l=p.l;
b=p.b;
h=p.h
/* peut également être écrit comme *this=p;*/

}
void Box:: afficher()
{
cout << l << " " << b << " " << h;
cout << ceci l << ceci b << ça h;
}
vide main()
{
Boîte B1;
Boîte B2 (5, 7, 11);
Boîte B3 = B1;
B1. montrer( );
B2. montrer( );
B3. montrer( );
}

LIMITATIONS DE CECI
Ce pointeur pointe toujours vers l'objet appelant, ainsi il ne peut pas être
incrémenté ou décrémenté. C'est un pointeur constant.

Boîte = *q;
 Q = ceci+1 // valide
Q=++cela // pas valide

EN UTILISANT LE MOT CLÉ « const »

1. Variable const
pointeur vers const C
3. pointeur constant
4. pointeur constant vers une variable constante
[Link]ètres constantes
6. membres de données de la classe
7. membre fnd'une classe

Variables « const »
void main ( )
{
const float pi=3.14;
}
Les variables constantes sont initialisées au moment de la déclaration, ce qui signifie qu'elles sont lues.
seules les variables et leurs valeurs ne peuvent pas être manipulées.

cout << pi++ ; // pas valide.

Pointeur constant
const int *p; // lu comme "p est un pointeur vers un int constant"
vide main()
{
int b=50;
int a =10;
const int *p; // peut également être écrit comme "int const *p"
p= &a;
 *p=20;// opération invalide
p=&b;// opération valide
}

int * const P :-est un pointeur constant vers un entier signifie que P ne peut pas être incrémenté ou
décrémenté. Ainsi, ils sont initialisés au moment de la déclaration.
le pointeur "this" appartient à la catégorie ci-dessus.

void main()
{
int b=50;
int a=10;
int * const p=&a;
*p=20;
p=&b

paramètre « const » :
Lorsque le modificateur const est utilisé avec un paramètre pointeur dans une fonction
liste de paramètres, la fonction ne peut pas modifier la variable que le pointeur
points à.
Par exemple,

int strlen(const char *p)

Ici, la fonction strlen est empêchée de modifier la chaîne à laquelle p pointe.

Travaillant sur le même thème, le prototype d'un constructeur de copie est en fait

<classname>(<classname> &<referencename>)

Par exemple :
Boîte (const Boîte &p) // prototype du constructeur de copie par défaut
{
L=p.l;
B=p.b
H=p.h
}
Membres de données const de la classe
Souvent, nous avons des membres de données dans une classe dont les valeurs devraient rester
inchangés après leur initialisation. Pour créer de tels membres, nous pouvons utiliser le « const ».
mot-clé devant leur déclaration et ces membres sont appelés "const"
membres. Mais ils doivent être initialisés à l'aide d'initialisateurs.
Par exemple

classe cercle
{
int rad;
const float pi; // Ceci est invalide
};

Plutôt, la classe devrait avoir un constructeur pour initialiser 'pi' en utilisant des initialisateurs.

classe cercle
{
int rad;
const float pi; // Ceci est invalide
public :
cercle
{
rad=r;
}
};

Fonction membre constante :-

si nous voulons qu'un fncela ne devrait pas être autorisé à changer la valeur de la classe
membre que nous les rendons constants.

classe cercle
{
int r;
float a;
public :
void obtenir (int x)
{
 r=x;
}
void cal_area ( )
{
a = r * r * 3,14;
}
void show ( ) const
{
compte << "Rad=" << r << " Aire=" << a;
}
si const est là, alors la valeur de r ne changera pas sinon à la fin elle
sera augmenté.

INITIALISATEURS

Initialisateurs
C'est une syntaxe spéciale attribuée par C++ utilisée pour initialiser ces choses.

1. const membres de données dans la classe.

2. variables de référence
[Link] du constructeur paramétré de la classe de base depuis la classe dérivée.

Ils sont toujours écrits devant les constructeurs

Les ordres des initialisations doivent être les mêmes que ceux de l'ordre des membres de données

classe Données
{
int x, y;
public :
(int I, int j): x(i), y(j)
{

}
Données (int I, int j): x(i+j), y(x+i)
{
}
};

C'est le cas
Données D(5,10)
 5
Y=10
Données D(7,14)
X=21
Y=28

PASSAGE D'OBJETS EN UTILISANT DES POINTEURS

classe Boîte
{
int l, b, h;
public
void get( )
{
// même que précédemment
}
int comparer (Box *);
};
int Box :: comparer (Box *p)
{
int x, y;
x= l*b*h;
y=P l* p b* p h;
si (x == y)
return (0);
si (x > y)
retourner (1);
sinon
retourner (-1);
}
void main( )
{
Boîte B1, B2;
B1. obtenir( );
B2. obtenir( );
B1. montrer( );
B2. montrer( );
int ans ;
ans = B1. comparer (&B2);
si (ans == 0)
 cout << " les deux sont égaux ";
sinon si (ans==1)
cout << "b1 est supérieur à b2";
sinon
cout << "b2 est plus grand que b1";
}

Passage d'objets par référence en utilisant une variable de référence

classe Boîte
{
int l, b, h;
public:
void obtenir( )
{
// même que précédemment;
}
vide afficher()
{
// identique à la précédente ;
}
int comparer (Box &);
};
int Box:: comparer (const Box &P)
{
int x, y;
x = l*b*h;
y = p.l*p.b*p.h;
si (x==y)
retourner (0);
sinon si (x > y)
retourner (1);
sinon
retourner (-1);
}

vide principal()
{
Boîte B1, B2;
[Link]( );
 [Link]( );
[Link]( );
[Link]( );
int réponse;
ans=B1. comparer (B2);
si (ans == 0)
cout<<" les deux sont égaux ";
sinon si (ans==1)
cout << "b1 est plus grand que b2";
sinon
cout << "b2 est plus grand que b1";
}

FONCTIONS D'AMI
Une fonction amie est une fonction spéciale qui, malgré le fait de ne pas être
membre fnde la classe a un accès complet aux membres privés et protégés de la
classe.

ATTRIBUTS DES FONCTIONS AMIES

1.s'il y a un F
fonction
doit être fait ami d'une classe, alors il doit être déclaré dans
le corps de la classe précédé par le mot-clé ami.
[Link] les fois qu'un ami f n'est défini ni le nom de la classe ni le scope
n

L'opérateur de résolution apparaît dans sa définition. De plus, le mot-clé ami

n'apparaît pas non plus.
3. chaque fois qu'un ami fns'appelle, ni le nom de l'objet ni le point
l'opérateur apparaît vers sa gauche. Il peut cependant accepter - l'objet comme un
4.
5.
6. paramètre dont il souhaite accéder aux membres.
7. Peu importe dans quel diction de classe nous déclarons une fonction amie.
Nous pouvons toujours y accéder depuis n'importe quelle partie du programme.

[Link] un ami fnvouloir manipuler les valeurs des membres de données d'un objet
envoie la référence de l'objet à passer en paramètre

Exemple :-// Démontrant l'utilisation de la fonction amie

classe étudiant
{
int rouler;
note de caractère;
flottant per;
public
void get( );
ami vide montrer (étudiant);
};
void étudiant:: obtenir()
{
cout << "entrez le matricule. Note & pourcentage";
cin >> roll>> grade>>per;
}
void montrer (étudiant P)
{
cout << [Link]<< " " << [Link]<< " " <<[Link];
}
vide principal()
{
étudiant S;
S. obtenir( );
montrer(S);
}

Démonstration de l'utilisation de la fonction amie

classe étudiant
{
int rouleau;
char note;
flottement per;
public:
ami vide obtenir (étudiant &);
void show( );
};
void get (étudiant & P)
{
cout << entrez le numéro, la note et le pourcentage ;

cin >> [Link] >> [Link] >> [Link];

}
void étudiant : : montrer( )
{
cout << roll << grade << per;
}
vide principale()
{
Étudiant S;
vide obtenir(S);
s. montrer();
}

classe étudiant
{
int roule;
caractère note;
flottant par;
public
ami vide obtenir (étudiant *P);
vide afficher();
};
void get (étudiant *q)
{
cout << "entrez numéro, note et pourcentage";
cin >>q rouler >> q note >> q par;
}
vide étudiant :: montrer ()
{
cout << roll << grade << per;
}
void main( )
{
Étudiant s;
Obtenir (&s);
[Link]( );
}

UNE FONCTION ÉTANT AMIE DE DEUX CLASSES

classe Beta; // déclaration anticipée
classe Alpha
{
int x;
public
vider obtenir()
{
cout << "entrez x=";
cin >> x;
}
ami vide comparer (Alpha, Bêta);
};
classe Bêta
{
int y;
public :
void set( )
{
cout << "entrez y=";
cin >>y;
}
ami vide comparer (Alpha, Beta);
}
void comparer (Alpha A, Beta B)
{
si (A, X > B. Y)
cout << "plus grand=" << A, X;
sinon si (B.Y > A.X)
cout << "Supérieur=" << B.Y;
autre
cout << "égal";
}
vidé principal( )
{
Alpha Obj1;
Bêta Obj2;
Obj1. obtenir( );
Obj2. set( );
Comparer (obj1, obj2);
}
AJOUTER DEUX OBJETS D'UNE CLASSE EN UTILISANT DES FONCTIONS MEMBRES

classe Distance
{
int pieds;
int dans le cher
public
vide obtenir( )
{
cout << "entrez des pieds et des pouces";
cin >> pieds >> pouces;
}
Ajout de distance (Distance &)
void afficher()
{
cout << “pieds=” << pieds << “pouces=” << pouces;
}
};
Distance Distance : : ajouter (Distance &P)
{
Distance température;
Temp. pieds = pieds + P. pieds;
[Link] = pouces + [Link];
si (temp. pouces >= 12)
{
temp. feer += temp. pouces / 12;
temp.
}
Retourner (temp);
}
vide principal()
{
Distance D1, D2, D3;
D1. obtenir( );
D2, obtenir( );
D3 = D1. ajouter (d2);
D3. montre( );
}
classe Distance
{
int pieds, pouces;
public :
void obtenir( 0
{
// même que précédemment
}
void ajouter (distance &, distance &);
void afficher()
{
// le même que précédemment;
}
};
void distance::add(distance &d1, distance &d2)
{
Pieds = d1. pieds + d2, pieds;
pouces = d1. pouces + d2, pouces
si (pouces >12)
{
Pieds = pieds + pouces / 12;
Pouces % = 12;
}
}
void main( )
{
Distance d1, d2, d3; [Link]( );, [Link]( );
D3, ajouter (d1, d2);
D3. montrer( );
}

AJOUTER DEUX AF CLASSES EN UTILISANT LA FONCTION PRIED

classe distance
{
int pieds;
int pouces;
public :
 void obtenir()
{
entrez des pieds et des pouces
cin >> pieds >> pouces;
}
vidéo montrer()
{
//même
}
ami distance ajouter (distance, distance) :
};
ajouter la distance (distance P, distance Q)
{
distance température
[Link] = [Link] + [Link];
temp. pouces = [Link] + [Link];
si (temp. pouces >= 12)
{
[Link] += [Link] / 12;
temp. inches % = 12;
}
retourner (temp);
}
vide principal()
{
distance D1, D2, D3;
[Link]( );
[Link]( );
D3 = ajouter (D1, D2)
[Link]( );
}

Surcharge d'opérateurs
C'est un mécanisme permettant à un programmeur de créer des fonctions intégrées.
L'opérateur de C++ agit sur des objets de classes définies par l'utilisateur de manière très similaire à
ils agissent sur des variables de type de données primitif. Ainsi, nous pouvons dire en utilisant l'opérateur
surcharge d'un programmeur peut augmenter la portée de fonctionnement de l'opérateur intégré à partir de
type primitif à type non primitif également.

L'un des principaux avantages de la surcharge des opérateurs est la simplicité

dans la lisibilité de l'appel c'est-à-dire fnles appels qui sont donnés en utilisant la surcharge d'opérateur sont
beaucoup plus facile à interpréter par rapport aux appels de fonction conventionnels.

Le surcharges d'opérateurs peut être effectuée

1. Faire usage de la fonction membre

2. utiliser une fonction amie.

Syntaxe :-
<type-ret> opérateur <symbole-op> (arguments);
ami (ret-type> opérateur <op-symbol> (<arguments>);

Surcharge de l'opérateur unaire en tant que fonction membre de la classe

(Pré-incrémentation)

classe compteur
{
int compte;
public
compteur( )
{
compte = 0;
}
compteur (int c)
{
compter = c
}
void opérateur ++();
void montrer()
{
cout << count << end1;
}
};
vide compteur : : opérateur ++ ( )
{
++ compteur;
 }
void main( )
{
compteur a = 10 ; // Constructeur à un seul paramètre
[Link]( );
++ a; // a. opérateur + +( );
a. montrer();
}

classe Compteur
{
int count;
public
Compteur()
{
Compter = 0;
}
Compteur (int c)
{
c
}
Opérateur de compteur ++ ( );
vide montrer( )
{
cout << count;
}
};
Comptoir &
Ou
Compteur Compteur : : opérateur ++ ( )
{
Compteur de température;
++ compteur; ou
temp. compte = compte; ++ compter
retourner (temp); retourner (* cela);
}
vide principale()
{
Compteur c1 = 10, c2;
montrer( );
 C2 = ++ c1;
C1. montrer( );
C2. montrer ( );
}

Surcharge de l'opérateur d'incrémentation post-inc de cette classe en utilisant une fonction membre

classe Compteur
{
int compteur;
public :
Compteur()
{
compte=0;
}
Compteur(int C)
{
compte = c;
}
Opérateur de compteur ++ (int);
void afficher()
{
cout << count;
}
};
Compteur Compteur : : opérateur ++ (int)
{
Température de contre
Temp. count = count++;
retourner (temp);
}
void main()
{
Compteur c1 = 10, c2;
C2 = c1++;
C1. montrer( );
C2. montrer( );
}

Surcharge de l'opérateur unaire en tant qu'ami de la classe

classe compteur
{
int compte;
public :
compteur( 0
{
compte=0;
}
compteur (int i)
{
Je
}
vide montrer()
{
cout << count << fin1;
}
ami void opérateur ++ (compteur &);
};

void opérateur ++ (compteur &C)

{ Ou
++ [Link] température de contre
retourner (C); temp. count = [Link]++;
} retourner (temp);

vide principal ()
{
10
C1. afficher ( );
C2. = ++C2;
C1. montrer ( );
C2. montrer( );
}

Remarque :-lorsque les opérateurs unaires sont surchargés en utilisant une fonction membre alors
n'acceptez aucun argument sauf lorsqu'ils sont surchargés en utilisant l'ami fnalors ils
avoir un argument de type objet (classe).

classe compteur
{
int compte;
public
opérateur d'ami ++ (compteur &);
compteur
{
count =0;
}
compteur (int i)
{
compte = i;
{
void show( )
{
cout << count << fin1;
}
};

opérateur de compteur ++(compteur &c)

{
température de contre
[Link]=++[Link];
retourner(temp);
}

void main()
{
compteur c1=10,c2;
[Link]();
c2=++c1;
[Link]();
[Link]();
getch();
}

Surcharge des opérateurs binaires en tant que fonctions membres de la classe

D3 = D1 + D2;
D3 = D1. opérateur + (D2);

classe Distance
{
int pieds, pouces;
public
vide obtenir( )
{
Comptez << "entrez les pieds et les pouces";
cin >> pieds >> pouces;
}
void montrer( )
{
cout << pieds << pouces;
}
Opérateur de distance + (Distance);
};
Distance Distance : : opérateur + (Distance P)
{
Distance t;
[Link] = pieds + [Link]
t. pouces = pouces + P. pouces;
si ([Link] >= /12)
{
[Link] + = [Link]/12;
12
}
Retourner (t);
}
vide principal()
{
Distance D1, D2, D3;
D1, obtenir( );
D2, obtenir( );
D3 = D1 + D2;
D3. montrer( );
Getch( );
}
 Surcharge de l'opérateur binaire à l'aide d'une fonction amie

classe Distance
{
int pieds, pouces;
public
vide obtenir()
{
cout << "entrez des pieds et des pouces" :
cin >> pieds >> pouces ;
}
vide montrer( )
{
cout << pieds << pouces ;
}
ami Opérateur de distance + (Distance, Distance);
};
Opérateur de distance + (Distance p, Distance Q)
{
Distance t;
[Link] = [Link] + [Link];
[Link] = [Link] + [Link];
si (t. pieds >= 12)
{
[Link] = [Link] + [Link] / 12;
12
}
Retourne (t);
}
void main ( )
{
Distance D1, D2, D3;
[Link]( );
[Link]( );
D3=D1+d2;
[Link]();
}

Affectation :-
D2 = D1+n
 D3 = n + D1

classe Distance
{
int pieds, pouces;
public:
void get( )
{
// identique au précédent
}
void show( )
{
// même que le précédent
}
Distance Distance : : opérateur + (int n)
{
Distance température;
Temp pieds = pieds + n;
Temp. pouces = pouces + n;
si (temp. pouces >= 12)
{
Temp. pieds + = temp. pouces / 12;
Temp. pouces % = 12;
}
Retourner (temp);
}
Opérateur de distance + (int P, Distance Q)
{
Distance temp;
[Link] = P + [Link];
Temp. pouces = P + Q. pouces;
si ([Link] >= 12)
{
[Link] = temp. pieds + temp. pouces / 12;
Temp. pouces % = 12;
}
Retourner (temp);
}
void main( )
{
 Distance D1, D2, D3;
int n;
cout << "entrez un entier";
cin >> n;
D1. obtenir ( );

Je D2 = D1+n; peut être fait en utilisant la fonction membre fn& ami fn

D2. montrer( );
cout << "Entrez un entier";
cin >>n;
II D3 = n+D1; // pas possible à travers le membre fn
D3. montrer();
}

Remarque :-
II ne peut pas être fait en utilisant une fonction membre car n est un entier et seulement un
un objet peut appeler une fonction, pas un entier. Donc, un appel peut être effectué en utilisant une fonction membre.
ainsi que la fonction amie mais II ne peut être fait que fonction amie

Devoir :- D1+=D2 utiliser le membre fn& ami fn

Surcharge des opérateurs relationnels

si (D1 = = D2)
Compilateur si ([Link]érateur == (D2))

classe Distance
{
int pieds, pouces;
public
void obtenir( )
{
cout << entre pieds et pouces ;
cin >> pieds >> pouces;
}
void montrer( )
{
cout << pieds << " " << pouces;
}
int opérateur = = (distance D);
};
int Distance::operator==(Distance D)
{
int x, y;
X = pieds & 12 + pouces;
Y = [Link] * 12 + [Link];
si (x == y)
Retourner (1);
sinon
Retourner (0);
}
vide principal( 0
{
Distance D1, D2;
D1. obtenir( );
D2. obtenir( );
D1. montrer( );
[Link]( );
si (D1 == D2)
cout << "égal";
sinon
cout << "pas égal";
}

Devoir :
Modifiez le programme ci-dessus pour que maintenant votre cosle imprime soit l'un de
il message
Les objets sont égaux.
ii. Dl est plus grand.
iii. D2 est plus grand
Utilisez le minimum d'opérateurs possible

Surcharge de l'opérateur binaire sur une chaîne

classe chaîne
{
char str[20];
public
chaîne ( )
 {
str[0] = '\0';
}
chaîne (char *P);
{
strcpy (str, P);
}
vide montrer()
{
cout << str;
}
chaîne opérateur + (chaîne S)
};
chaîne chaîne : : opérateur + (chaîne S)
{
chaîne t;
int i, j;
pour (i=0; str[i]; i++)
[Link][i] = str[i];
pour (j=0; [Link][j]; i++, j++)
[Link][i] = [Link][j];
retourner (t);
}
void main( )
{
Bonjour
Comment ça va ?
chaîne s3;
s3 = s1 + s2;
s1. montrer( );
s2. montrer( );
s3. montrer( );
}

Devoir :-
WAP qui compare deux objets de chaîne et vérifie lequel est
plus grand.

Opérateurs qui ne peuvent pas être surchargés

 1>.(opérateur point) opérateur d'accès aux membres (déjà surchargé)
2>:: (opérateur de résolution de portée) il fonctionne déjà sur les classes que nous surchargeons
seulement ces opérateurs qui fonctionnent sur les primitifs et non sur les non primitifs
3>?: (opérateur conditionnel) Il nécessite la surcharge de trois arguments.
les opérateurs peuvent prendre au maximum 2 arguments

4>*. Opérateur de pointeur vers membre

Taille de l'opérateur

ALLOCATION DYNAMIQUE DE MÉMOIRE (ADM)

MALLOC NOUVEAU
C'est une fonction C'est un opérateur
2. Nécessaire d'inclure le fichier d'en-tête fichier d'en-tête non requis
3. Cela prend aucun, d'octets comme paramètre Il faut le nombre d'éléments
Requis en tant que paramètre
4. amène la mémoire depuis le tas local bring n'a pas de tel store de mémoire
5. Mémoire maximale que malloc Le nouveau n'a pas de telle mémoire

peut allouer = 64KB limitation

6. Malloc renvoie l'adresse de Nouveau se convertit automatiquement
Allouer un bloc devant (void*) selon le type de données donné
Ainsi, sa valeur de retour doit être de type donc pas besoin de taper explicitement
Casté en conséquence cast son valeur de retour.
7. lorsque malloc échoue, il retourne null lorsque nouveau échoue, il retourne zéro
8. Malloc ne crée qu'un nouveau bloc d'autre part opérateur new
Mais ne pas appeler le constructeur du peut allouer de la mémoire ainsi que
classe pour initialiser le membre de données appelle la classe pour l'initialisation
De ce bloc les membres du bloc créés. Tel
Les constructeurs sont appelés dynamiques
Constructeurs.

Syntaxe pour nouveau ;

(i) nouveau <type de données>

(ii) nouveau <type-de-données> [int];

Allocations de nouveaux :-
1. int * P; new permet au programmeur d'initialiser la mémoire
P = nouveau int (10); alloué mais malloc ne fournit pas une telle fonctionnalité
cout << *P;
supprimer P;

2000 10

P 2000 2002

2. int *P; Ici, la valeur 10 signifie que

P=new int [10]; le programmeur s'intéresse à créer de la mémoire pour
supprimer [ ] P; éléments

3000

P 3000

Syntaxe pour supprimer

1. supprimer <ptr-name>; // supprime un bloc de type de données

2. supprimer [ ] <nom-du-pointeur>;
// supprime toute la mémoire allouée

float *P;
supprimer P; quatre octets libres

La suppression est une demande au système d'exploitation, elle ne s'exécute pas immédiatement tandis que la création de nouveau fonctionne.
mémoire immédiatement

WAP qui crée un tableau dynamique de taille définie par l'utilisateur Accepter les valeurs de l'utilisateur
dans ce tableau & puis trouver le plus grand élément de ce tableau ainsi que sa position.
Enfin, il devrait afficher le plus grand élément et supprimer le tableau.

void principal()
{
int n;
 cout << "Combien d'entiers";
cin >> n;
int *p;
p = nouveau int[n];
si (p == 0)
{
cout << "Mémoire insuffisante";
getch( );
exit(1);
}
pour (int i=0; i<n; i++)
{
cout << "entrez un élément";
cin >> * (p+i);
}
int max = *p;
int pos = 0;
pour (i=1; i<n; i++)
{
si (*(p+i) > max)
{
max = *(p+i);
pos = i;
}
}
cout << "élément le plus grand=" << max;
cout << "Position =" << pos;
getch( );
supprimer [ ] p;
}

WAP pour créer une classe c/a chaîne ayant un pointeur de caractère P. Fournir un constructeur
dans la classe qui accepte un int comme paramètre et alloue un tableau dynamique de caractères
de taille spéciale. Maintenant, fournissez le membre suivant fndans la classe.

1. obtenir une chaîne qui invite les utilisateurs à entrer une chaîne dans un tableau dynamique.
qui affiche la chaîne
2. afficher la chaîne
3. Inverser la chaîne qui accepte un objet comme paramètre et copie le
Inverse de la chaîne stockée dans l'objet appelant dans l'objet
Passé en paramètre.
classe chaîne
{
char *p;
int n;
public :
chaîne (int);
chaîne ( );
void showstr( );
void inverserchaine ( chaîne &);
void getstr( );
};
chaîne : : chaîne (int taille)
{
p = nouveau char [taille +1];
si (p == 0)
sortie (1);
n = taille +1;
}

void chaîne : : obtenirchaîne( )

{
cout << "entrez une chaîne";
cin. getline (p,n);
}
void chaîne :: inverserChaine (chaîne &s)
{
int i, j;
pour (i=0, j=strlen (p)-1; j>=0; j--, i++)
{
s.p[i] = p[j];
}
s. p[i] = '\0';
}

vide chaîne : : afficherstr( )

{
cout << p << fin1;
}
chaine : : chaine ( )
{
supprimer [ ]p;
cout << " Tableau détruit";
}
void main ( )
{
int n;
cout << "Combien de caractères";
cin >> n
chaîne S1 = n;
chaîne S2 = n;
S1. obtenirchaine ( );
S1. inverser str(S2);
S1. afficher str( );
S2. montrer str( );
}

OBJETS DYNAMIQUES
Allouer de la mémoire pour une classe avec l'aide de new.

classe Emp
{
int âge;
char nom[20];
flottant sal;
public:
vide obtenir()
{
cout << "entrez l'âge, le nom et le salaire";
cin >> âge >> nom >> salaire;
}
void afficher()
{
cout << age << " " << name << " " << sal;
}
};
void main( )
{
Emp *P;
 P=new Emp();
si (P==0)
{
cout << "Mémoire insuffisante";
sortie (1);
}

P obtenir( );
P montrer( );
getch ( );
supprimer p;
}

P âge

TABLEAU D'OBJETS DYNAMIQUES

Modifiez le code précédent pour que votre programme crée un tableau d'objets.
où n est donné par l'utilisateur. Ensuite, il doit accepter des valeurs pour chaque objet et enfin
affichez-les.

classe Emp
{
int âge;
char nom[20];
flottant sal;
vide obtenir()
{
cout << "entrez l'are, le nom et le salaire";
cin >> âge >> nom >> salaire ;
}
void montrer( )
{
cout << age << nom << sal << end1;
}
};
void main( )
{
Emp *p;
int i, n;
cout << "combien d'employés ?";
cin >> n;
p=new Emp[n];
si ( p == 0)
{
cout << "erreur dans la création des objets";
sortie (1);
}
pour (i=0; i<n; i++)
(p+i) obtenir( ); ou p[i]. get( );
pour (i=0; i<n; i++)
(p+i) montrer( ); ou p[i]. afficher( );
getch( );
supprimer[ ]p;
}

Améliorez le programme ci-dessus afin qu'après avoir accepté les enregistrements de n employés.
Le programme demande à l'utilisateur de saisir un autre nom et d'afficher l'enregistrement de celui-ci.
employé seulement. si le nom de l'employé n'est pas disponible, alors le programme doit afficher le
enregistrement de message non trouvé.

class Emp
{
int âge;
char nom [20];
flottant sal;
public :
vide obtenir( )
{
cout << "entrez l'âge, le nom et le salaire";
cin >> âge >> nom >> salaire;
}
void montrer()
{
cout << âge << nom << sal;
}
 int comparer (char *);
};
void main ( )
{
Emp *p;
int n;
cout << "combien d'employés ?";
cin >> n;
P= nouveau emp [n];
si (p == 0)
{
cout << "Mémoire Insuffisante";
sortie (1);
}

pour (i=0; i<n; i++0

(p+i) get( ); ou p[i]. get( );
cout << "entrez le nom à rechercher";
char str [20];
cin. ignorer();
[Link] (str, 20);
pour (i=0; i<n; i++)
{
si ( (p+i) comparer (str) = = 0)
{
(p+i) montrer ( );
pause;
}
}
si (i == n)
cout << " Enregistrement non trouvé";
getch ( );
supprimer [ ] p;
}
int comparer (char *p)
{
retourner (strcmp ( name.p) );
}
 CONSTRUCTEURS DYNAMIQUES

classe Emp
{
int âge;
char âge;
char nom [20];
flottant sal;
public
Emp( )
{
cout << "entrez l'âge, le nom et le salaire;"
cin >> âge >> nom >> salaire;
}
Emp (int I, char *j , float k)
{
Âge = I;
Strcpy (nom, j);
Sal = k;
}
void show( )
{
cout << age << " " name " " << sal;
}
~Emp( )
{
cout << "Objet détruit";
}
};
vide principal()
{
Emp *P, *q;
P=new Emp;
Q=new Emp (30, "vineet", 200000);
p montrer( );
q afficher();
supprimer q;
supprimer p;
}
Remarque :- Le programme ci-dessus ne appellera pas le destructeur de la classe même à
résiliation. Cela est dû au fait qu'en C++, la mémoire qui est allouée en utilisant new ne peut que
l'emplacement de l'accord est uniquement effectué lors de la suppression et de l'appel du destructeur lorsque la mémoire
est désalloué. Comme dans le code ci-dessus, l'appel à delete n'est pas présent, donc la mémoire
le bloc reste toujours dans la RAM et pourrait être récupéré à l'avenir par le biais du ramassage des ordures
collection. Ainsi, si la mémoire est libérée pour un objet dynamique, cela ne peut être fait que
par l'opérateur delete.

HÉRITAGE

Héritage simple 2. Héritage multi-niveau

Une classe de base Une classe de base indirecte de C

Classe dérivée B Classe de base B de C

3. Héritage multiple 4. Héritage hiérarchique

A B Un

C B C

5. Héritage hybride ou héritage multipath

Un
 B C

Syntaxe pour l'héritage :

classe <nom_de_classe>: public / privé / protégé <nom_de_classe>

Mode d'héritage de la classe dérivée Classe de base

classe Boîte
{
int l, b, h;
public:
void obtenir( )
{
cout << "entrez l, bande";
cin >> l >> b >> h;
}
void montrer()
{
cout <<l<< " " << b<< " " << h;
}
};
classe carton : public Boîte
{
char type[20];
public
void set( )
{
cout << "entrez le nom du matériau";
[Link] (type, 20);
}
void afficher ( )
{
cout << "matériau =" << type;
}
};
void main( )
{
objet en carton
obj. obtenir();
obj. set( );
obj. montrer( );
obj. afficher( );
}

Règles d'accessibilité lorsque le mode d'héritage est public

Lorsqu'une classe de base est héritée en mode public, alors :-

Tous les membres publics de la classe de base deviennent des membres publics de la classe dérivée.

classe c'est-à-dire qu'ils peuvent également être accessibles par la fonction de la classe dérivée
comme par des objets de classe dérivée.
[Link] les membres protégés de la classe de base deviennent des membres protégés de
classe dérivée & donc ne peut être accessible que par les fonctions de la classe dérivée
mais pas par l'objet (principal) de la classe dérivée.
3. Tous les membres privés de la classe de base restent privés pour leur propre classe et ne peuvent donc pas
ne peut être accédé ni par les fonctions de la classe dérivée ni par l'objet de la classe dérivée
classe.

LIEN PRÉMATURÉ :-
C'est un prours qui s'exécute lors de la compilation dans lequel
compiler binaire le fncorps avec le fnappel c'est-à-dire même avant le début du programme
exécution de la décision concernant le fnappeler et fnle corps à exécuter est pris par le
compilateur puisque cela se produit avant l'exécution, nous pouvons dire que c'est un liaison hâtive. Hâtive
Le lien est toujours une action jusqu'à ce que le mot-clé virtuel soit utilisé devant le f.n
type de retour. Cela se fait sur la base de ces critères :-

(i) nom de fonction ou

(ii) appel de type d'objet ou
(iii) type de paramètre de fonction

En d'autres termes, le liaisonnement précoce est toujours en action dans un f [Link],

surchargé fnappels et opérateurs surchargés
 Le principal avantage de la liaison précoce est la rapidité d'exécution, c'est-à-dire la fonction
Les appels qui sont liés en utilisant le lien précoce s'exécutent à la vitesse la plus rapide car
comparé à la liaison tardive fnappels.

SURPASSER
L'override de fonction est un terme utilisé lorsqu'une classe dérivée
contient une fonction avec le même prototype que sa classe de base. En d'autres termes, fn
fournie par la classe de base a le même prototype dans la classe dérivée mais avec un corps différent.

Surcharge Surcharge
La portée doit être différente toujours dans la même classe
Par les classes liées par signifie à un niveau unique
Héritage

Prototype de fonctions le prototype doit être différent

Doit être le même.

Lorsque le mode de transmission est protégé

Lorsque la classe de base est héritée en mode protégé, alors :-

Tous les membres publics de la classe de base deviennent des membres protégés de la classe dérivée.
c'est-à-dire qu'ils ne peuvent être accessibles que par fonction de la classe dérivée mais pas par
objet de la classe dérivée.
[Link] les membres protégés de la classe de base deviennent des membres protégés de la classe dérivée

classe c'est-à-dire qu'elles ne peuvent être accessibles que par les fonctions de la classe dérivée
mais pas par un objet de la classe dérivée.
3. Tous les membres privés de la classe de base restent privés à leur propre classe et donc
ni accessible par l'objet ni par les fonctions de la classe dérivée.

classe Num
{
protégé
int a, b;
public:
vide obtenir( )
{
cout << "entrez deux nombres";
cin >> a >> b;
 }
vide montrer( )
{
cout << "Les nombres sont =";
cout <<a << " " << b;
}
};

classe AddNum : protégé Num

{
Protégé :
int c;
public:
void set( )
{
obtenir( );
}
vide ajouter( )
{
c=a+b;
}
void afficher( )
{
montrer();
cout << "somme=" <<c;
}
};
vide principale ( )
{
AjouterNum obj;
obj. set( );
[Link]( );
obj. afficher();
}

MODE D'HÉRITAGE PRIVÉ

Lorsqu'une classe de base est héritée en mode privé, alors :
 [Link] les membres publics de la classe de base deviennent des membres privés de la classe dérivée.

classe c'est-à-dire qu'elle ne peut être accessible que par fnde la classe dérivée mais pas par le
objets de la classe dérivée.
[Link] les membres protégés de la classe de base deviennent des membres privés de la classe dérivée.

c'est-à-dire qu'ils ne peuvent être accessibles que par la fonction de la classe dérivée mais
pas par des objets de la classe dérivée.
[Link] les membres privés de la classe de base restent privés à leur propre classe et ainsi
ne peut être accessible par fnni par des objets de classe dérivée.

classe Num
{
protégé
int a, b;
public
void obtenir()
{
cout << "entrez a et b";
cin >> a >> b;
}
void montrer()
{
cout << "a = "<<a<<end1;
cout << "b= "<< b<< endl;
}
};

classe AddNum: privée Num

{
protégé :
int c;
public :
void définir()
{
obtenir( );
}
vide ajouter( )
{
c=a+b;
}
vide afficher ( )
 {
montrer( );
cout << "somme = " << c;
}
};
void main( )
{
AjouterNum Obj;
[Link]( );
Obj. ajouter( );
Obj. afficher( );
}

Remarque : - Lors d'une hérite simple, l'héritage privé et protégé semble être
similaire.

HÉRITAGE MULTI-NIVEAUX

classe Num
{
protégé
int a, b;
public :
vide obtenir( )
{
cout << "entrez a et b" :
cin >> a >> b;
}
void montrer()
{
cout << "a=" << a << end1;
cout << "b=" << b << endl;
}
};
class AjouterNum : public Num
{
protégé
int c;
public :
void set( )
 {
obtenir( );
}
void afficher()
{
montrer( );
cout << "somme=" << c;
}
vide ajouter( )
{
c=a+b;
}
};

classe DiffNum : public AddNum

{
int d;
public:
void accepter( )
{
ensemble( );
}
vide diff( )
{
d = a - b;
}
void imprimer()
{
afficher ( );
cout << "Différence=" << d;
}
};
void main()
{
Objet DiffNum;
obj. accepter( );
obj. ajouter( );
obj. diff( );
obj. print( );
}
Programme

classe compteur
{
protégé
int count;
public :
void init(int a)
{
a;
}
void opérateur ++( )
{
compter ++;
}
void montrer( )
{
cout << "count=" <<count;
}
};
classe DecCounter : public counter
{
public :
vide opérateur - -( )
{
- - compter;
}
};
vide principal( )
{
Deccounter D;
[Link](10);
[Link]( );
++D;
[Link]( );
- - D;
D. montrer( );
}
Devoir :-
Créer un tableau de classe c/a qui contient un tableau d'entiers de taille 10. Le
La classe devrait avoir deux fonctions membres appelées getArr et showArr, qui devraient
accepter les valeurs dans le tableau et afficher ses valeurs respectivement. Maintenant, créez un dérivé
classe de tableau c/a sortarr, la classe doit accepter une chaîne comme paramètre si la chaîne
contient 'asc' alors le tri doit être effectué par ordre croissant & s'il contient
Le tri « desc » doit être effectué par ordre décroissant.

Enfin, créez la fonction principale qui devrait contenir un menu principal.

interface utilisateur

(i) entrée
(ii) affichage
(iii) trier par ordre croissant
(iv) trier par ordre décroissant
(v) quitter

Solution #include <iostream.h>

#include <stdlib.h>
classe Tableau
{
protégé
int a[5];
public
void obtenir( );
void afficher( );
};
void Tableau :: obtenir()
{
int i;
cout << "entrez les éléments du tableau";
pour (i=0; i<5; i++)
cin >>a[i];
}
void Tableau : : afficher ( )
{
pour (int i=0; i<5; i++)
cout << " les éléments sont =" << a[i];
}
classe sortarr : public Array
{
public:
void ascsort( );
void descsort( );
};
void trierTab : : trierAsc ( )
{
int i, j, t;
pour (i=0; i<5; i++)
{
pour (j=0; j<4; j++)
{
si (a [j] > a [j+1])
{
t = a [j];
a [j] = a [j+1];
a [j+1] = t ;
}
}
}
}
void trier_tab : : decroissant( )
{
int i, j, t;
pour (i=0; i<5; i++)
{
pour (j=0; j<4; j++)
{
si (a[j] < a[j+1])
{
t=a[j];
a[j]=a[j+1]
a[j+1] = t;
}
}
}
}

void main( )
{
clrscr( );
sortarr sr;
int ch=0;
faire
{
Entrez (1) pour entrer des données
Entrez (2) pour Afficher les Données
Entrez (3) trier dans l'ordre croissant
Entrez (4) pour trier par ordre décroissant
Entrez (5) pour quitter
cout << "entrez votre choix";
cin >> ch;
clrscr( );
switch (ch)
{
cas 1 :
[Link]( );
pause;
cas 2 :
[Link]( );
pause;
cas 3 :
[Link]( );
pause;
cas 4 : [Link]( );
pause;
cas 5 :
sortie(1)
}
} pendant que (ch !=5)
getch( );
}

HÉRITAGE MULTIPLE

classe base1
{
protégé :
int a;
 public:
vide obtenir()
{
cout << "entrez a =";
cin >>a;
}
void montrer( )
{
cout << a << fin1;
}
};
classe base2
{
protégé
int b;
public:
vidé set( )
{
cout << "entrez b=";
cin >> b;
}
void afficher( )
{
cout <<b << fin1;
}
};

class drv : public base1, public base2

{
int c;
public :
void accepter ( )
{
obtenir( );
ensemble( );
}
ajouter ( )
{
c=a+b;
}
 vide imprimer( )
{
montrer( );
afficher( );
cout << "sem =" << c;
}
};
void main( )
{
drv obj;
obj. accepter( );
obj. ajouter( );
obj. print( );
}

Programme :-
Base et dérivée ayant la fonction avec le même nom et les mêmes arguments.

classe base1
{
protégé
int a;
public
void get( )
{
cout << "entrez a=";
cin >>a;
}
void montrer()
{
cout << a << fin1;
}
};
classe de base2
{
protégé
int b;
public :
void set( )
{
 cout << "entrez b=";
cin >> b;
}
vide afficher( )
{
cout <<b<<end1;
}
};

classe drv : public base1, public base2

{
int c;
public :
void accept( )
{
get( );
set( );
}
void ajouter()
{
c=a+b;
}
void imprimer( )
{
Va montrer montrer( ); base1: : afficher();
Ambiguïté d'erreur : montrer( );
erreur
}
};
vide principal()
{
Drv obj;
obj. accepter( );
obj. ajouter( );
obj. imprimer( );
}

Rôle du constructeur et du destructeur dans l'héritage

 En règle générale dans l'héritage, si une classe de base contient un constructeur et
le destructeur ainsi que la classe dérivée contiennent également un constructeur et un destructeur, alors quand
l'objet de la classe dérivée est créé, le constructeur de la classe de base s'exécute en premier
suivi du constructeur de la classe dérivée et le destructeur est appelé dans l'ordre inverse
c'est-à-dire que le destructeur de la classe dérivée est appelé en premier, suivi par le destructeur de la classe de base
classe.

Ainsi, nous pouvons dire que les constructeurs sont toujours appelés dans l'ordre de l'héritage et
les destructeurs sont appelés dans l'ordre inverse.

classe Base
{
public :
Base ()
{
cout << "Dans le constructeur de base" << end1;
}
~Base( )
{
cout << Dans le destructeur de base « << end1;
}
};

classe drv : public Base

{
public :
drv( )
{
cout << “Dans const de dérivée “ << end1;
}
~drv( )
{
cout << "Dans le destructeur dérivé " << end1;
}
};
void main()
{
{
drv obj;
}
 getch( );
}

CONSTRUCTEUR DE PARAMÈTRES

classe Base
{
Protégé :
int a, b;
public :
Base (int I, int j)
{
Je
b = j;
}
void afficher()
{
cout << a << " " << b;
}
};
classe drv : public base
{
int c;
public
drv ( ): Base (10, 20)
{
c=a+b;
}
vide montrer()
{
Base : : montrer( );
cout << "somme = " << c;
}
};
void main( )
{
drv obj1
drv obj2
obj1. montrer( );
 obj2. montrer( );
}

Appel de constructeur dans l'héritage multiple

Base 1 base2 drv

int a; int b; int c;

Base1 (int); base2 (int);
vide montrer( ); void afficher();

classe Base1
{
protégé:
int a;
public :
Base (int i)
{
a = i;
}
void montrer()
{
cout << a;
}
};
classe Base2
{
protégé :
int b;
public :
Base2 (int j)
{
b = j;
}
void afficher( )
{
 cout << b;
}
};

classe drv : public Base1, public Base2

{
protégé :
int c;
public :
drv (int p, int q) : Base1 (p), Base2(q)
{
c=a+b;
}
vide imprimer ( )
{
montrer ( );
afficher( );
cout << "leur somme =" << c;
}
};
void main( )
{
drv obj1 (10, 20);
drv obj2 (20, 70);
obj1. imprimer ( );
obj2. print( );
}

Remarque :-
si le constructeur de la classe de base est paramétré alors

(i) la classe dérivée doit avoir un constructeur

(ii) Le constructeur de la classe de base doit être appelé dans le constructeur dérivé.

Appel de constructeur dans l'héritage multilevel

classe Base1
{
protégé
int a ;
 public
Base1(int i)
{
a=i;
}
void montrer( )
{
cout << a << fin1;
}
};
classe Base2 : public Base1
{
protégé
int b;
public :
Base2 (int i, int j) : Base1(i)
{
b=j;
}
void afficher()
{
cout << b << fin1;
}
};
classe drv : public Base1, public Base2
{
protégée
int c;
public
drv (int x, int y) : base2 (x, y)
{
c=a+b;
}
void imprimer ( )
{
afficher( );
afficher ( );
cout << "leur somme=" << c;
}
};
 void main ( )
{
drv obj(10, 20);
drv obj (50, 60);
obj1. imprimer( );
obj2. print( );
}

Remarque
Les constructeurs ne peuvent pas être hérités :-

Les constructeurs sont des membres spéciaux fnqui sont exclusivement utilisés pour
initialisation des membres de données privés de la classe. Maintenant, puisque les données privées de la classe ne sont pas
transmis à ses classes dérivées, donc les fonctions qui les initialisent explicitement
(le constructeur) ne sont pas hérités. Il en va de même pour le destructeur,

HÉRITAGE HIÉRARCHIQUE

classe Num
{
protégé :
int a, b :
public :
Num (int i, int j)
{
a = i;
b = j;
}
void montrer()
{
cout << "a =" << a;
cout << "b=" << b;
}
};
classe AddNum : public Num
{
int c;
public :
AjouterNum (int i, int j) : Num (i, j)
{
 c=a+b;
{
void afficher( )
{
Num : : montrer( );
cout << " somme =" <<c;
}
};

classe Diffnum : public Num

{
int d;
public :
DiffNum (int x, int y) : Num (x, y)
{
d = a - b;
}
void afficher( )
{
Num : : montrer( );
cout << " Différence =" << d;
}
};
vide principal( )
{
AddNum addobj (10, 20);
DiffNUm diffobj (30, 70);
addobj. montrer( );
diffobj. Montrer();
}

HÉRITAGE HYBRIDE

classe Base
{
public
int a;
};
classe drv1 : public Base virtuel
{
 public :
int b;
};
classe drv2 : public virtuel Base
{
public:
int c;
};
classe drv3 : public drv1, public drv2
{
public :
int d;
};
void main()
{
drv3 obj;
obj. a =10;
obj. b = 20
obj. c =30;
obj.d = obj.a + obj.b + obj.c;
cout << "somme =" << obj,d;
}

ACCÈS À LA RÂPE
classe Données
{
privé
int a;
Protégé :
int b;
public :
int c;
};
classe drv : protégé Data
{
public :
Données : : C // mettre C en mode public au lieu de protégé
};
Foreg:-
classe Banque
{
public :
void dépôt( );
void retirer( );
void int-cal( );
};
classe d'épargne - compte : Banque Privée
{
public :
Banque
Banque
};

POLYMORPHISME

classe Base
{
public :
void afficher()
{
cout << "Dans la base '& show";
}
};
classe drv : public Base
{
public :
void afficher()
{
cout << "Dans le spectacle de drv";
}
};
void main()
{
Base b, *ptr;
drv d;
ptr = & b;
 ptr montrer( );
ptr = & d;
ptr montrer( );
}

FONCTION VIRTUELLE & HÉRITAGE MULTI-NIVEAUX

classe Base
{
public :
virtuel void afficher( )
{
cout << "Dans le spectacle de la base";

}
};
classe drv1 : publique Base
{
public :
void afficher( )
{
cout << "Dans le spectacle de drv1";
}
};
classe drv2 : public drv1
{
public:
void afficher()
{
cout << "Dans le spectacle de drv2";
}
};
void main( )
{
Base * ptr, b;
drv1 d1;
drv2 d2;
ptr = & b;
ptr montre( );
ptr = & d1;
 ptr montrer( );
ptr = &d2;
ptr afficher( );
}

Remarque :-
La classe de niveau supérieur ptr peut accéder aux membres de la classe de niveau inférieur. Virtuel est
mandaroty dans la base s'affiche comme fonction est à l'origine de la base.

Les fonctions virtuelles sont celles pour lesquelles aucune décision n'est prise concernant l'appel.
et la définition à exécuter est token par le compilateur lors de la compilation. Dans
d'autres mots, si un fnest précédé du mot-clé virtuel alors si jamais ne devient le passé
de la liaison anticipée et le compilateur retarde sa liaison jusqu'à l'exécution. Ainsi, toutes les décisions
Concernant l'appel et le corps à exécuter, ils sont pris à l'exécution.
les décisions ne sont pas basées sur le type d'appelant (comme c'était le cas avec le lien anticipé)
mais sur la base du contenu de l'appelant. si le pointeur d'appel stocke l'adresse
de l'objet de la classe de base, la version de la fonction virtuelle de la base sera exécutée et si cela
pointer vers un objet de classe dérivée alors version dérivée de f virtuellenest exécuté.

Mais pour tirer pleinement parti du potentiel de la fonction virtuelle, la classe dérivée doit
donner son propre corps / définition pour f virtuelndoit garder son prototype identique à le
la classe de base c'est-à-dire que la classe dérivée doit remplacer la fonction virtuelle de la classe de base si elle le souhaite
placer sa propre définition de fonction virtuelle.

C'est parce que le pointeur de la classe de base ne peut accéder qu'à ces fonctions de
dériver des classes qui sont remplacées dans la classe dérivée mais pas celles qui sont
caché ou ajouté par une classe dérivée.

Fonctionnement interne de la fonction virtuelle

classe A TABLE VIRTUELLE POUR A

{
int a; &A : : f2( )
public
void f1( ) &A : : f3( )
{
}
virtuel void f2( ) obj1 VPTR a
{
}
}; TABLE VIRTUELLE POUR B
classe B : publique A &B : : f2( )
{ int x;
public : &A : f3( )
vide f4( );
void f2( ); obj2 VPTR
};

void main()
{ taille de la classe A = 4 octets
A obj1;
Un *ptr; 2 octets pour la variable a
ptr = & obj1; 2 octets pour VPTR
ptr f2( );
ptr = & obj2;
ptr f3( );
ptr f4( );
} Cela ne sera pas exécuté car ce n'est pas virtuel et le compilateur
ira au tableau de liaison hâtive pour la classe de base A où il n'y a pas de fonction f4.

-
pour chaque classe en C++ qui contient au moins une fonction virtuelle, un
une table de recherche spéciale pour stocker les adresses de leurs fonctions virtuelles est créée qui
est connu sous le nom de VTABLE ou table virtuelle. Ainsi, en résumé, VTABLE est une table
contenant les adresses des fonctions virtuelles de la classe ainsi que la fonction virtuelle de
classe de base si elles ne sont pas remplacées. Cette table est ensuite consultée par le compilateur
lorsqu'un appel à une fonction virtuelle est rencontré pendant l'exécution.

VVPTR : (Pointeur virtuel nul)

pour chaque classe qui contient une fonction virtuelle, un pointeur spécial est
créé par le compilateur connu sous le nom de VVPTR, qui est utilisé pour pointer vers le virtuel
table. Ainsi, chaque objet d'une classe contenant une fonction virtuelle a sa taille
incrémenté de 2. Maintenant, chaque fois que le compilateur rencontre un appel à une fonction virtuelle
à travers un pointeur, il fait d'abord référence à l'adresse de l'objet auquel le pointeur fait référence
à partir de leur cela lit l'adresse contenue dans VVPTR de l'objet qui est le
adresse de VTABLE de classe. Enfin, à l'intérieur de la VTABLE, elle exécute le virtuel
La fonction est appelée. Ainsi, la fonction virtuelle augmente la taille du code tout en réduisant le
vitesse d'exécution mais offre un moyen flexible de concevoir des programmes qui peuvent
répondre aux changements qui se produisent au moment de l'exécution.

classe Données
{
int a ;
Données (int );
public :
static Data getObject();
void montrer( );
};
Données : : Données (int i)
{
a = i;
}
Données Données : : obtenirobjet()
{
Données D(10);
retourner (D);
}
vide Données :: montrer()
{
cout << a;
}
vide principal()
{
Données D = Donné[Link]();
D. montrer( );
}
Remarque
Lorsqu'un seul objet de la classe est créé, ce type de classe est c/a unique.
à n classe.

Polymorphisme
Polymorphisme à la compilation Polymorphisme en temps d'exécution

1. Surcharge de fonction 1. Surcharge de fonction

2. Surcharge d'opérateurs 2. Fonction virtuelle
3. Liaison précoce 3. Liaison tardive

Héritage Virtuel évite les copies multiples

Polymorphisme
(convertit la liaison anticipée en liaison tardive)

classe Figure
{
protégé
int dim1, dim2;
public :
void obtenir( )
{
entrez 1st& 2etdimension
cin >> dim1 >> dim2;
}
};
class Rectangle : public Figure
{
public :
void zone()
{
cout << "aire du rectangle =";
cout << dim1 * dim2;
}
};

classe Triangle : public Figure

{
public
void zone( )
{
cout << "aire =" << '5 * dim1 *dim2;
 vide imprimer( )
{
montrer( );
afficher( );
cout << "sem =" << c;
}
};
void main( )
{
drv obj;
obj. accepter( );
obj. ajouter( );
obj. print( );
}

Programme :-
Base et dérivée ayant la fonction avec le même nom et les mêmes arguments.

classe base1
{
protégé
int a;
public
void get( )
{
cout << "entrez a=";
cin >>a;
}
void montrer()
{
cout << a << fin1;
}
};
classe de base2
{
protégé
int b;
public :
void set( )
{
 Une classe qui étend une classe de base abstraite doit fournir sa propre
définition de f virtuel purndisponible dans sa classe de base sinon la classe
il serait créé en tant que classe abstraite et lui aussi ne peut pas être
instancié.

Remarque : les constructeurs ne peuvent pas être virtuels car il y a un lien entre VPTR et VTABLE.
est fabriqué par le constructeur

Destructeur virtuel :-

classe de base
{
protégé
int *p;
public : base()
{
p=new int [10];
cout << " p construit!";
}
base virtuelle
{
supprimer [ ] p;
cout << "mémoire désallouée";
}
};
classe drv : public Base
{
int *q;
public :
drv( )
{
q = nouveau int [10];
cout << " q construit";
}
~drv( )
{
supprimer [ ] q;
cout << "mémoire désallouée pour q";
}
};
vide principal()
{
Base *ptr;
ptr = nouveau drv;
supprimer ptr;
}

Un destructeur ne peut pas être déclaré comme virtuel pur. Puisqu'il n'est pas possible de laisser
corps vide du destructeur puisque au moment de l'appel du destructeur la même activité doit
être exécuté.

FICHIER - MANIPULATION (E/S DE FLUX)

Flux de données

si le flux de données va du programme vers le dispositif, alors le flux de sortie par exemple cout. est utilisé.

si le flux de données va de l'appareil au programme alors le flux d'entrée par exemple cin est utilisé.

Moniteur Moniteur

Flux d'entrée flux de sortie

Programme C++

Flux d'entrée flux de sortie

Disque dur Disque dur

Classes disponibles en C++ pour la gestion de fichiers

[Link] Stream:- si une classe dont les objets peuvent être créés pour écrire des données à
mémoire secondaire de fichier.
2. Il Stream :- est une classe dont les objets peuvent être créés pour lire des données
depuis le fichier.

[Link] dont l'objet peut lire / écrire les données dans un fichier.

Étapes requises pour écrire des données dans un fichier

Étape Créer l'objet de la classe « De flux »

Exemple : Objet de flux;
Étape 2Connectez l'objet avec le fichier sur votre système.
Étape Écrivez les données à travers l'objet dans le fichier.
Étape Fermez le fichier.

Implémentation C++ des étapes ci-dessus

Étape 1(a) D'objet de flux;

Étape 2 obj. Ouvrir ("Data. Txt");
Étape 3(a) obj << "Bonjour";
(b) obj. mettre ('H');
Étape 4 [Link] ( );

1 (a) De flux Obj ( "Données, txt");

2(a) D'un objet de flux; classe données statiques
Bj. ouvrir ("Données. Txt", ios : : application)
Mode d'ouverture de fichier

3 D'objet de flux ("[Link]", ios::app)

Étapes pour créer un programme de lecture d'un fichier

1. Créez l'objet de la classe “ifstream”.

2. Connectez l'objet avec le fichier sur votre système et vérifiez si le fichier est
disponible ou non.
3. Lire les données à travers un objet depuis un fichier.
4. fichier de classe.

MISE EN ŒUVRE C++

 1.s'il s'agit d'un objet de flux

2. (a) Obj. Ouvrir ("[Link]);

Ou
si flux obj;
Objouvrir ("[Link]", ios::in);
Ou
si objet flux ("[Link]", ios: : in);

Création d'un objet de la classe fstream

1. fstream obj;
[Link] ( “[Link]”, ios : : sortie | ios : : entrée);
2. Utilisation du constructeur
Fstream obj ( "[Link]", ios :: out | ios :: in);

WAP pour créer un fichier c/a "[Link]" Accepter une ligne de texte de l'utilisateur et l'écrire
dans le fichier caractère par caractère

#include <stdlib.h>
#include <iostream.h>
#include <fstream.h>
#include <conio.h>

void main ( )
{
De flux sortant ("Message. Texte");
si (!out)
{
cout << "le fichier ne peut pas être ouvert";
Getch ( );
exit(1);
}
char str[80];
cout << "entrez une ligne de texte";
[Link] (str, 80);
int i=0;
Tant que (str[i])
{
[Link] (str[i]);
I++;
 }
cout << "fichier écrit avec succès";
Getch ( );
Hors. Fermer( );
}

1
Remarque :- ( ) Renvoie 1 si connecté
0
1
Échouer( ) Retourne I si non connecté
0

Que:- WAP pour ouvrir le fichier créé par le programme précédent. Lire caractère par caractère.
par caractère de base et afficher son contenu à l'écran.

Solution :-
vide principal ( )
{
si flux dans ("[Link]");
si (! dans)
{
cout << "le filoe ne peut pas être ouvert";
exit(1);
}
char ch;
Tant que (! [Link]( ) )
{
Ch=[Link]( );
cout << ch;
}
Getch();
[Link]( );
}

Que :- WAP pour ouvrir un fichier c/a "[Link]". Accepter une ligne de texte de l'utilisateur et l'écrire.
sur fichier caractère par caractère basique et cela dans le même programme lire le fichier et imprimer
son contenu à l'écran.

vide principal( )
{
Fstream Nisha ( "Données", ios::out | ios::in);
si (! Nisha)
{
cout << "erreur d'ouverture du fichier";
sortie(1);
}
char str [80];
cout << "entrez une ligne de texte";
[Link] ligne (str, 80);
int i=0;
char ch;
Tant que (str [i])
{
Ch=str[i];
[Link](ch);
I++;
}
[Link] (0);
Tant que (! [Link]( ))
{
Ch=[Link]( );
cout << ch;
}
Getch( );
Obj. fermer( );
}

Que Supposons qu'il y ait un fichier c/a "Message. Txt" contenant certaines lignes de texte.
Créer un fichier c/a "[Link]", et copier le contenu de "[Link]" dedans.
Avant de copier, le caractère doit être converti de majuscules en minuscules et vice versa.
les espaces doivent être skipper. Enfin, afficher le contenu de "Message2 txt".

void main( )
{
si flux obj1 ( "[Link]" );
Flux obj2 ("[Link]", ios::out | ios::in);
char ch;
si (! Obj1)
{
 cout << le fichier source ne peut pas être ouvert ;
sortir(1);
}
Tant que (! Obj1, eof)
{
Ch = [Link]();
si (ch! = 32)
{
si (ch>=65 && ch<=90)
Ch=ch+32;
sinon si (ch >= 97 && ch <= 122)
Ch=ch-32;
}
[Link](ch);
}
[Link](0);
Tant que ( ! obj2. eof( ) )
{
Ch=[Link]( );
cout << ch;
}
Getch( );
[Link]( );
Obj1. fermer( );
}

LIRE ET ÉCRIRE DES CHAÎNES

void main ( )
{
Fstream obj ( "[Link]", ios::out | ios::in);
si !(!obj)
{
cout << "erreur";
sortie (1);
}
caractère texte [80];
cout << "combien de lignes";
int n;
cin >> n;
 cout << "Entrez " << n << " lignes, chacune terminée par un saut de ligne : " << end1;
pour (i=1; i<=n; i++)
{
[Link] ligne (texte, 80);
Obj << texte << fin1;
}
Obj. seekg (0);
cout << "Fichier écrit, appuyez sur une touche pour lire";
Gecth( 0;
Tandis que (![Link]())
{
[Link] (texte,80);
cout << text << end1;
}
Gecth( );
[Link]( );
}
vide principal()
{
Fstream obj ( "[Link]", ios :: out | ios :: in);
si (!obj)
{
cout << "erreur";
exit(1);
}
char texte [80];
cout << "entrez des lignes et appuyez sur entrée sur une nouvelle ligne pour arrêter";
Tant que (1)
{
[Link] (texte, 80);
si (strlen (texte) == 0)
Pause;
Obj << texte << fin1;
}
}

MODES D'OUVERTURE DE FICHIERS

ios : : hors (Mode par défaut d'ofstream)

si le fichier n'existe pas, il est créé. Sinon, les données sont mises à jour.
 Effacé et le pointeur est placé au début.

2. ios : : dans
si le fichier existe, le pointeur est placé au début sinon
une erreur est générée.
3. ios : : application
Il ne peut pas modifier le contenu précédent mais peut ajouter du nouveau contenu au
Fin de fichier.

4. ios : : a mangé (ate signifie à la fin)

Permet des mises à jour ainsi que l'ajout de nouvelles données.
Dans ce pointeur, vous pouvez avancer et reculer.

5. ios : : tronquer
Nécessaire uniquement dans fstream.
Utilisé avec iOS : : hors
Tronquer les données précédentes et ramener le pointeur au début.

6. ios : : nerplace
Utilisé avec iOS : : si le fichier existe, ne le remplacez pas, sinon
créez-le.

7. ios : : nocreate
Utilisé avec iOS : : si le fichier existe, écrasez-le, sinon ne le faites pas.
créez-le.

8. ios : : binaire
si nous voulons écrire des données sous forme binaire.

I/O BINAIRE

vide écrire (char *, int )

De ruisseau adresse de la variable nombre d'octets à écrire
Membre dont les données doivent être
Écrit

int a = 23091 ;
Obj, écrivez (( char *) &a, taille de (int) );
char b = 'x';
[Link](0);
int c;
Obj. lire ( (char *) &c, taille de (int ) );
cout << c;
char d;
Obj. lire (&d, taille de (char) );
cout <<d;
int lire (char *, int)
Adresse de la variable dont les données doivent être stockées après lecture
À partir du fichier
Lors de la lecture réussie du fichier, cela renvoie 1 ; en cas d'erreur, cela renvoie 0.

Lecture et écriture d'objets de classe

classe Emp
{
int âge;
char nom [20];
flottant sal;
public:
void obtenir( )
{
cout << "entrez l'âge, le nom et le salaire";
cin >> âge >> nom >> salaire;
}
void montrer()
{
cout << âge << <<nom << " " sal <<fin1;
}
};

vide principal()
{
Emp E;
Fstream obj ( "[Link]", ios :: out | ios :: in | ios :: trunc | ios ::
Binaire );
si (! Obj)
{
cout << "erreur lors de l'ouverture du fichier";
 sortie (1);
}
[Link]();
[Link]((char *) &E, taille de (Emp));
[Link](0);
Emp F;
[Link] ((char *) &F, taille de (Emp));
[Link]();
Getch( );
[Link]( );
}

Lire et écrire plusieurs objets

vide principal ( )
{
Emp E;
Fstream obj ( "[Link]", ios::out | ios::in | ios::trunc | ios:: )
Binaire);
si (! Obj)
{
Erreur lors de l'ouverture du fichier
sortie (1);
}
char choix;

{
[Link]( );
[Link] ((char *) &E, taille de (Emp));
cout << "Encore (O/N)";
[Link]();
cin >> choix;
} pendant ( ch = = 'y');
Obj. seekg (0);
Tant que ([Link] (char *) &E, taille de (emp))
[Link]();
getch( );
[Link]();
}
Caractéristique typique de la lecture :

Remarque :- si dans n'importe quel programme, nous voulons lire un fichier successivement jusqu'à la fin du fichier
nous devons dégager le drapeau
Obj. seekg (0);
Obj. clear( );

Q. Écrivez un programme pour écrire plusieurs enregistrements de type emp dans un fichier. Acceptez un nom de l'utilisateur.

& afficher le dossier de l'employé en le recherchant dans le fichier et afficher

le message approprié

vide principal()
{
int plat = 0
Emp E;
Fstream obj1 ( "Ekta, txt", ios :: out | ios :: in | ios :: trunc |
Ios : ; binaire);
si (! Obj)
{
cout << "erreur";
sortir(1);
}
caractère ch;
Fais
{
[Link]( );
[Link]((char *)&E, taille d'Emp);
cout << "Ant encore (o/n)";
[Link]();
} tandis que (ch = = 'Y');
char nom [20];
cout << "entrez le nom à rechercher";
cin >> nom;
Obj. seekg(0);

Tant que ([Link](char *) &E, taille de (emp))

{
si ( ! ( E == nom) )
{
E. afficher( );
 Drapeau = 1;
Pause;
}
}
si ( ! drapeau) ou si (drapeau == 0)
{
cout << " Enregistrement non trouvé";
Obj1. Fermer( );
}
int opérateur = = (char * ptr)
{
Retourner (strcmp (nom, ptr) );
}
}

E/S ALÉATOIRE

Q. Supposons qu'il y ait un fichier c/a "[Link]" qui contient plusieurs enregistrements de type
emp. WAP pour ouvrir ce fichier et lire le dernier enregistrement.

vide principal ( )
{
ifstream in ( "[Link]", ios :: in | ios :: binaire);
si ( ! dans)
{
cout << "erreur";
quitter (1);
}
[Link] (-1 * taille de (emp), ios :: fin);
Emp E;
Dans. lire ( ( char *) &E, taille de (emp));
[Link]();
[Link]( );
Getch( );
}

Remarque :- Prototype de seekg( )

vide seekg (int, int)
Non, de position de mouvement
 Octets à ios : : commencer
Déplacer ios : : cur
Ios : : fin

Programme pour accepter un nom de l'utilisateur. Rechercher l'enregistrement de cet employé dans
"[Link]" & Ajoutez un nouvel enregistrement à sa position en l'acceptant de l'utilisateur

void main()
{
char temp[20];
Emp E;
Fstream in ( "[Link]", ios :: in | ios :: ate | ios :: binaire);
cout << "entrez un nom à mettre à jour";
cin >> temp;
[Link](0);
Tant que ([Link] ( (char *) &E, taille de (emp) )
{
si ( ( E == temp) == 0)
{
[Link]( );
[Link] (-1 * taille de (Emp), ios : : cur);
[Link] ( ( char *) &E, taille de (emp));
Pause;
}
}
[Link]( );
[Link](0);
Tandis que ([Link]((char *)&E, taille de(Emp)))
[Link]( );
int opérateur = =(char *n)
{
Retourner (strcmp (temp, ptr) );
}
}

Devoir :-

1. Programme pour supprimer un enregistrement fourni par l'utilisateur d'un fichier.

2. Programme pour mettre à jour juste le salaire de l'employé dont le nom est donné par l'utilisateur.
 MODÈLES
Les templates sont une technique fournie par C++ qui permet à un programmeur
peut définir une seule fonction dans laquelle le dernier à être exécuté est mentionné mais le
le type de données n'est pas mentionné. Pendant l'exécution, en regardant l'appel de la fonction et
son type de paramètre, le compilateur génère une version spécifique de cette fonction pour agir
selon le paramètre passé.

Ainsi, en d'autres termes, nous pouvons dire que les modèles sont des fonctions génériques
qui, au moment de la création, ne reçoivent que des instructions sur ce qu'ils doivent faire et au moment de l'exécution, ils

prenez conscience du type d'argument qui doit être fait.

Les modèles sont de deux types

(i) Modèle de fonction
(ii) classe Modèle

Modèle de fonction de syntaxe

Modèle <classe <nom-de-type>> <type-de-retour>
< nom-de-fonction> (< nom-de-type> <nom-d'argument>)

Exemple

Modèle <classe T>

void afficher ( T n)
{
cout << n << finl;
}
int main ( )
{
int a = 10;
char b = 'x';
float c= 11.5;
Afficher (a);
Affichez (b);
Afficher (c);
 }

Écrivez un modèle de fonction c/a échange qui accepte deux paramètres et les échange.
Les paramètres passés peuvent être deux entiers, deux flottants, deux classes. Enfin, deux échangés.
les valeurs doivent être affichées dans la fonction principale

Modèle <classe T>

void échanger ( T &a, T &b)
{
T temp;
Temp = a;
A= b;
B = temp;
}
void main ( )
{
int a, b;
cout << "entrez deux entiers";
cin >> a >> b;
Échanger (a, b);
cout << 'a= "<<a<< "b=" <<b<<end1;
cout << "entrez deux caractères";
char p, q;
cin >> p >> q;
Échanger (p, q);
cout << "p= "<<p<<'q = "<<q <<end1;
flottant x, y;
cout << "entrez deux nombres à virgule flottante";
cin >> x >> y;
Échanger (x, y);
cout << "x= "<<x<< "y= "<<y << endl;
}

Q. écrivez un modèle de fonction qui accepte deux valeurs comme argument et retourne
maximum parmi eux.

Modèle <classe T>

T supérieur à (T &P, T 7q)
{
 si ( p > q)
Retourner (p);
sinon
Retourner (q);
}
vide principal()
{
int a, b;
cout << "entrez deux entiers:";
cin >> a >> b ;
cout << " maximum = "<< greater (a, b);
cout << "Entrez deux caractères :"
char x, y;
cin >> x >> y;
cout << "maximum =" << greater (x, y);
}

Écrivez un modèle de fonction c/a le plus grand qui accepte un tableau comme argument &
renvoie le plus grand élément de ce tableau. Le tableau passé peut être de types différents
et de taille différente.

Modèle <classe T>

T plus grand (T *a, int n)
{
int I;
T max = *a;
pour (i=1; i<n ; i++)
{
si ( * (a+i) > max)
Max = * (a+i);
}
Retourner (max);
}
void main ( )
{
int arr[ ] = {7, 11, 2, 3, 4, 8};
float brr[ ] = { 10.4, 11.3, 6.5, 8.2};
cout << "max int =" << max (arr, 6);
cout "max float=" << max (brr, 4);
}
 MODÈLE DE CLASSE

Modèle <classe T>

classe Données
{
T a;
T b;
T c;
public :
void obtenir()
{
cin >> a >> b;
}
vide ajouter ( )
{
C = a + b;
}
vide montrer( )
{
cout << " les valeurs sont =" << a << end1;
cout << b;
cout << "somme=" << c;
}
};
vide principale ( )
{
Données <int> obj1;
Données , double> bj2;
cout << "entrez deux int";
[Link]( );
cout << "entrez deux doubles";
Obj1, obtenir( );
Obj2. ajouter( );
Obj1. montrer( );
Obj2. montrer( );
}
classe Modèle Avec Différent Type Générique

Modèle <classe T1, classe T2>

classe Données
{
T1, a;
T2, b;
public
void get( )
{
cin >> a >> b;
}
void show( )
{
cout << "les valeurs sont =" << a << "et " << b << end1;
}
};
vide principal()
{
Données <int, float> obj1;
Data <double, char> obj2;
cout << "entrez un int et un float";
[Link]( );
[Link]();
cout << "entrer un double et un caractère";
[Link]( )
[Link]( );
}

Q. écrivez un modèle de classe pour une classe appelée pile et implémentez trois bases
opérations de la pile push, pop et peek. La pile peut être de int, char et flots.

Modèle <classe>
classe pile
{
T arrêt [S];
int tos;
public :
 Pile ( )
{
Tos = -1;
}
T pop ( );
};
Modèle <class T>
vide pile <T> : : pousser (T n)
{
si (tos == 4)
{
cout << "débordement de pile";
Retour;
}
++ tos
Arr [tos] = n;
}
Modèle <classe T>
T pile <T> : : dépiler ( )
{
si (tos == -1)
{
cout << "débordement de pile";
Retourner(-1)
}
Retourner (arr [tos - -]);
}

void main ( )
{
Pile <int> sa;
int n;
Pile <char> s2;
char ch;
pour (int i=1; i<=6; i++)
{
cout << "entrez un entier à ajouter";
cin >> n;
[Link](n);
}
 pour (int i=1; i<6; i++)
cout << " élément retiré =" << [Link]( );
}

Surcharge de l'opérateur d'assignation

classe chaîne
{
char *p;
public
chaîne (int);
void set string (char *);
void réinitialiserchaîne ( char *);
void afficher ( );
chaîne( );
};
chaîne : : chaîne (int n)
{
P=new int [n+1];
}
void string : : setstring (char *str)
{
Strcpy (p, str);
}
void string : : resetstring (char *s)
{
Strcpy (p, s);
}
vide chaîne : : afficher ( )
{
cout << p <<end1;
}
chaîne : : chaîne( )
{
Supprimer [ ] p;
cout << "Mémoire désallouée";
}
void main ( )
{
chaîne s1 = 20;
 chaine s2 = 20;
S11. setstring ( "Bonjour Utilisateur");
S2=s1;
S1. afficher ( );
S2. afficher ( ); void string::operator(string
S1. réinitialiser chaîne ("Bienvenue"); &s)
S1. afficher ( ); {
S2. afficher( ); strcpy 9p, s.p);
} x=s.x;
}

Remarque :-
quand la classe contient un pointeur dynamique, il est nécessaire de
surcharge de l'opérateur d'assignation

Au moment de la surcharge = il est nécessaire de passer le paramètre par référence.

(par exemple (chaîne & s)).

Remarque :-
Pour la cascade de l'opérateur d'assignation, il est nécessaire que le type de retour soit
chaîne

chaîne chaîne : : opérateur = (chaîne &s)

{
chaîne (p, s, p);
X= s,x;
Retourner (* ceci);
}

Remarque :-
Q. pourquoi surchargeons-nous l'opérateur d'assignation ?

Réponse : L'opérateur d'affectation par défaut fourni par C++ est utilisé pour copier un
objet de classe à un autre mais il copie la valeur bit par bit, c'est-à-dire la valeur contenue dans
Chaque bit de l'objet source est copié dans chaque bit de l'objet de destination. Cela
le comportement est parfait si la source cosle ne contient aucun pointeur vers dynamiquement
bloc alloué, mais si c'est le cas, alors l'opérateur d'égalité par défaut (=) sera simplement
copier l'adresse stockée dans le pointeur dans l'objet source vers le pointeur dans le
objet de destination. Cela fera en sorte que deux pointeurs différents pointent vers la même location
ce qui peut causer plusieurs problèmes comme l'appel du destructeur à l'opérateur delete pour
 c=a+b;
{
void afficher( )
{
Num : : montrer( );
cout << " somme =" <<c;
}
};

classe Diffnum : public Num

{
int d;
public :
DiffNum (int x, int y) : Num (x, y)
{
d = a - b;
}
void afficher( )
{
Num : : montrer( );
cout << " Différence =" << d;
}
};
vide principal( )
{
AddNum addobj (10, 20);
DiffNUm diffobj (30, 70);
addobj. montrer( );
diffobj. Montrer();
}

HÉRITAGE HYBRIDE

classe Base
{
public
int a;
};
classe drv1 : public Base virtuel
{
Réponse : En C++, tous les types primitifs comme int, float, char, etc. sont affichés sur la console.
utiliser l'objet prédéfini cout avec l'opérateur d'insertion (<<).
Maintenant, si le programmeur souhaite utiliser le même moyen d'afficher les objets de son
classe à l'écran alors il doit surcharger l'opérateur d'insertion et l'opérateur d'extraction afin que
ils peuvent être utilisés directement avec des objets définis par l'utilisateur.

Q. Pourquoi ne surchargeons-nous pas l'opérateur d'insertion et l'opérateur d'extraction en tant que fonction membre ?
Réponse : Les opérateurs d'insertion et d'extraction sont des opérateurs binaires et si l'opérateur binaire
est surchargée en tant que fonction membre de la classe, alors il y a une obligation de garder le
objet de la même classe à gauche de l'opérateur lors de l'appel. Ainsi, si cela est fait alors
wll deviendrait P << cout où P est un objet de classe. Maintenant cela viole le
la symétrie régulière de l'opérateur d'insertion et il doit donc être surchargé en tant qu'ami
fonction.

Q. L'opérateur d'égalité ne peut jamais être surchargé en tant que fonction amie.

Réponse : Étant donné que l'opérateur d'égalité devrait renvoyer la référence de l'objet appelant (pour prendre en charge
cascadage). Il doit être redéfini en tant que fonction membre car les fonctions amies ne le font pas.
avoir un objet d'appel

Remarque :-
L'opérateur d'égalité défini par la classe de base n'est jamais hérité par la classe dérivée
car il nécessite les mêmes membres dans l'objet source ainsi que dans l'objet de destination.

CONVERSION DE TYPE

La conversion de type est le processus par lequel un programmeur peut convertir une valeur de
primitif à non primitif et vice versa ainsi que d'un objet de classe à
un autre objet d'une classe différente.
Ainsi, la conversion de type se classe en trois catégories : -
1> De basique à défini par l'utilisateur
Défini par l'utilisateur en basique (primitif)
Défini par l'utilisateur à Défini par l'utilisateur

Conversion entre de base et utilisateur défini

Constructeur (Type de base

{
// étapes pour convertir de basique à défini par l'utilisateur
 }

Conversion entre défini par l'utilisateur et basique

Type primaire d'opérateur de C++ ( ) type de retour

{
Étapes pour convertir de basique à défini par l'utilisateur
Retourner (<de base – val>);
}

UtilisateurExemple À Basique & Basique À Utilisateur

classe Mètre
{
flottant longueur;

public :
Mètre ( )
{
0.0
}
Mètre (flottant cm)
{
Longueur = CM/100;
}
Opérateur float( )
{
Flaot ans= longueur * 100,0;
Retourner (ans);
}
void accepter mètres( )
{
cout << "entrer la longueur en (int mètres)";
cin >> longueur ;
}
void afficher mètre()
{
cout << "En mètres = " << longueur ;
}
};
void main ( )
{
Mètre M1 = 250;
Mètre M2;
[Link] Métre( );
float cm = m2; // float CM= M2. opérateur float( );
cout << "250 mètres une fois convertis";
M1. afficher Meter( ); M2. afficher Mètre( );
cout " lorsqu'il est converti en cms =" << cm
}

Programme :- Devoir

classe chaîne
{
char str [10];
public :
chaîne (int n)
{
Itoa (n, str, 10);
}

{
'\0';
}
Opérateur int( )
{
K=1;
I = strlen(str);
Tant que (i >= 0)
{
Somme = somme + (str [i] -48)* k
10;
Je - -;
}

Conversion d'utilisateur défini à utilisateur défini

1. Routine de conversion dans l'objet source :-

Opérateur <nom_de_classe_destination> ( )
 {
//routines pour convertir la source en destination
Retourner ( <destination – objet>);
}

2. Routine de Conversion Dans l'Objet de Destination :-

Constructeur ( <source – nom de classe>)
{
//routines pour convertir la source en diction
}

Conversion d'un défini par l'utilisateur à un autre défini par l'utilisateur en plaçant la routine de conversion
Dans l'objet source

classe Radian
{
flottant rad;
public :
Radian ( )
{
Rad = 0.0;
}
Radian (flottant r)
{
Rad = r;
}
void montrer( )
{
cout << "Radian =" << rad << end1;
}
};
classe Diplôme
{
flottant deg;
public:
Degré( )
{
Beg = 0.0;
}
Opérateur Radian ( )
 {
float x = deg * PI / 180;
Objet radian = x;
Retourner (objet );
}
void montrer()
{
cout << "Degré=" << deg;
}
void obtenirDegré()
{
cout << " entrez l'angle en degrés =";
cin >> deg;
}
};
vide principal ()
{
Diplôme D;
d. obtenirDegré( );
Radian R;
R=D;
D. afficher( );
R. montrer( );
}

classe Diplôme
{
flottant deg;
public :
Degré( )
{
Deg =0.0;
}
void show( )_
{
cout << "Degrés=" << deg;
}
void obtenirDonnées( )
{
cout << "entrez l'angle en degrés";
 cin >> deg;
}
Flaot getDree( )
{
Retour (deg);
}
};
classe Radian
{
flotte rad;
public:
Radian (Objectif en degrés)
{
Rad = [Link] Dece ( ) * PI/180 ;
}
Radian ( )
{
Rad=0.0;
}
void afficher( )
{
cout << " Radian +" << rad;
}
};
vide principal()
{
Degré D;
[Link]( );
Radian R = D; // Radian R (D);
D. montrer();
[Link]( );
}

Devoir :-

#include <iostream.h>
#include <conio.h>
heure de cours
{
flottant temps;
public :
Heure( )
{
Temps = 0.0;
}
Heure (double x)
{
Temps = x/3600;
}
Opérateur float( )
{
float x = temps * 3600;
Retourner(x);
}
void accepter( )
{
cout << "entrez le temps en heures";
cin >> temps;
}
vide montrer( )
{
cout << "dans l'heure =" << temps;
}
};
void main()
{
Heure t1=3600;
Heure t2;
T2. accepter( );
float x = t2;
cout << "3600 lorsqu'il est converti en heures=";
[Link]();
[Link]( );
cout << "lorsqu'il est converti en secondes =" << x;
Getch( );
}

OPÉRATIONS D'ENTRÉE/SORTIE DE LA CONSOLE

 Non formaté Formaté

1. I/O non formaté

(a) istream & get (char &) peut être
(b) int obtenir( ) appelé par cin
(c) istream & get (char *, int)

exemple :- [Link](ch);
Peut lire uniquement des caractères
cin=[Link]( );

Istream & getline (char *, int num, char delimiteur);

Istream & getline (char *, int num);

Exemple :-

void main ( )
{
char ch;
cout << "entrez du texte et appuyez sur entrée pour arrêter";
cin. Obtenir (ch);
Tant que (ch != ' ')
{
cout << ch;
[Link](ch);
}
Getch( );
}

void main()
{
char pays [20],
cout << "entrez le nom du pays :";
[Link] (pays,20); [Link] (pays, 20);
cout << "entrez le capital";
[Link] (capital, 20);
cout << "le pays est " << country << end1;
cout << "sa capitale = " << capital << end1;
}

Remarque :- [Link] (pays, 20, *)

Cela se terminera après 19 caractères ou en appuyant sur *, rien

se passera en appuyant sur entrer rey.

Fonctions de la classe Ostream

(a) ostream & put (char)
(b) ostream & écrire (char *, int)
Ceci commencera à partir de la base et ajoutera jusqu'au nombre d'entiers donné.

Exemple :
void main()
{
char str[ ] = { "programmation "};
int I;
pour (i=0; i<strlen (str); i++)
{
[Link] (str [i]);
cout << end1;
}
pour (i=1; i<=strlen(str); i++)
{
[Link] (str, i);
cout << end1;
}
pour (i=strlen (str) ; i>=1; i--)
{
[Link] (str, i);
cout << end1;
}
}

ENTRÉE/SORTIE FORMATÉE

Fonction Description

(i)largeur( ) spécifie le nombre de champs requis à utiliser pour l'affichage

la sortie. Ce fnest utilisé pour l'alignement.
(ii) précision( ) spécifie le nombre de valeurs à afficher après le point décimal

(iii) remplir( ) spécifie un caractère à utiliser pour remplir la zone inutilisée de

Champ. Par défaut, le remplissage est effectué en utilisant des espaces.

(iv) setf( ) définit le drapeau de format à utiliser lors de l'affichage

sortie.

(v) unsetf( ) efface les drapeaux définis à l'aide de setf et restaure la valeur par défaut
établissement.

Définir la largeur du champ

Prototype :- int largeur()

Renvoie la largeur actuelle.
int largeur (int)
Ancienne largeur largeur actuelle

vide principal()
{
cout. Largeur(4);
cout << 123;
[Link](4);
cout. << 39;
[Link](2);
cout << 2345
}

Réglage de la précision

Prototype :-int précision () Par défaut

précision (int) la précision est de 6 pt.

void main ( )
{
cout précision (2);
cout << 2.23 << end1;
cout << 5. 169 << end1;
cout << 4.003 << end1;
}
Sortie 2,23
5,17
4

Remplissage
int remplir( )
int remplir (char)

void main( )
{
[Link] ( ' * ' );
[Link](2);
[Link](6);
cout << 12.53;
[Link](6);
cout << 20.5;
cout. largeur(6);
cout << 2;
}
o/p 12,53 20,5 2

Remarque
Il n'est pas nécessaire de définir la largeur, le remplissage et la précision encore et encore.
doit être réglé encore et encore.

Formatage avec des drapeaux et des champs de bits

setf long soi (log-bits définis, long – champ)

Valeur-drapeau (1stchamp de bits (2ndDescription des arguments

Ios : : gauche ios : : ajuster le champ justifie la sortie sur
côté gauche.
Droit ios : : champ adjeist justifie la sortie en
alignement de la vue homme.
Ios : : interne ios : : ajuster le champ la passation se produit entre
le signe ou l'indicateur de base
& la valeur quand le
la valeur échoue à remplir le
largeur entière
ios : : déc ios : : champ de base afficher les données en décimal
conversion
ios : : oct “ afficher les données dans l'acteur
ios : : hax “ afficher les données en hexadécimal
ios : : scientifique ios : : champ flottant flottant exponentiel utilisateur
notation
iOS : : fixé “ notation flottante normale

Exemple :-

vide principal ()
{
[Link] (ios : ; gauche, ios : : ajuster le champ);
[Link]('*');
cout. precision (2);
[Link] (6);
cout << 12.53;
[Link] (6);
cout << 20.5;
[Link] (6);
cout <<2;
}
12,53 * 20,5 * * 2 * * * * *

vide principal()
{
[Link] (ios :: interne | ios :: ajuster le champ);
[Link] ('*);
cout. precision (2);
cout. largeur (10);
cout << -420,53;
}
-***420.53

Affichage des zéros finaux et du signe plus

Long auto (long – bits définis)
(i) ios : : montrer pôte (pour les zéros finaux)
(ii) ios : : afficher pos (pour le signe plus)
veillez à ce que je m'exprime correctement ( )

{
[Link](ios::showpoint);
[Link] (2);
cout << 20.55 << end1; sortie
cout << 55.55 << end1; 20.55
cout << 20.40 << end1; 55,55
} 20.40

Exemple :-
void main ( )
{
[Link] (ios :: showpoint);
[Link] (ios :: show pos);
[Link](ios::interne, ios::ajuster champ);
[Link]écision(3);
[Link] (10);
cout << 420.53;
}
Sortie
+ * 4 2 0 . 5 30

Mise en forme des données à l'aide de manipulateurs

Manipulateurs non paramétrés

Manipulateur Description

fin1 termine la ligne et transfère le curseur à la ligne suivante.

2 déc définir la base de conversion à 10.
3. bex réglez le champ de conversion à 16.
4. oct définir le champ de conversion sur 8
5. rincer vide l'écran de sortie

Exemple :-
1. Programme pour lire un nombre en décimal et l'afficher en hexadécimal.
vide principal ( )
{
cout << " entrer un nombre";
cin a;
cin >> a;
cout << " no est = " << n << fin;
cout << " Sa valeur hexadécimale= " << hex << n;
cout. self (ios :: show base);
cout << a;
}
64
Sa valeur hexadécimale = 40 0x 40

exemple : - vide principal ( )

{
int n;
cout << "entrez un nombre";
cin >> nex >> n;
cout << "nombre= " << n;
}

Manipulateurs paramétrés

Manipulateur Description

1. setw (int) définit la largeur du champ

2. setprecision (int) définit le nombre de chiffres à afficher après la virgule décimale
pinte
3. setfil (caractère) définit le caractère à être champ
4. setbase (int) définir la base de conversion. Voici les valeurs possibles de int
sont 8.10 et 16.
5. setiosflag (long) définit le drapeau de format.
6. resetiosflag (long) réinitialise le drapeau de format.

Exemple :-
vide principal ()
 {
int n = 100;
cout << hex <<n << " " << dec <<n << end1;
float f = 122.3434;
cout << f << end1;
cout << setprecision (3);
cout << f << fin1;
cout << setiosflag(ios::internal) | ios::showbase);
cout << hex << n << end1;
cout << setiosflag(ios::scientifique) << f << endl;
}

64 100
122.34339 9
122. 343
0x0064
1. 2 2 3 c + 0. 2

Surcharge de l'opérateur [ ]

classe Tableau
{
int *P;
int n;
public :
Tableau (int taille)
{
P=new int [taille];
N=taille;
}
int & opérateur [ ] (int i)
{
Retourner (* (p+i) );
}
void fil (int pos, int valeur)
{
(p+pos) = valeur;
}
Tableau ( )
{
 Supprimer [ ]p;
}
};
void main ( )
{
Array obj(5);
int x;
pour (int i=0; i<5; i++)
{
cin >> x;
[Link](I, x); ou obj[i] = x
}
pour (I = 0; i<5; i++)
{
cout << obj [i];
}
}

Surcharge de l'opérateur ( )

classe Boîte
{
int l, b, h;
public:
Opérateur de boîte ( ) (int, int, int);
void obtenir()
{
cout << "entrez l, b et h";
cin >> l >> b >> h;
}
void afficher()
{
cout << l, << " " << b << " " << h;
}
};
Boîte Boîte : : Opérateur (int l, int b, int h)
{
Boîte temp;
Temp.l = l + ceci l;
Temp.b = b + ceci b;
 Temp.h = h + ceci h;
Retourner (temp);
}
void main ( )
{
Boîte B1;
[Link]( );
Boîte B2;
B2 = B1 (5, 3, 9); // B2 = B1. opérateur ( ) (5, 3, 9);
B1. montrer( );
B2. montrer( 0;
}

PROGRAMMATION EN MODE GRAPHIQUE

Étapes requises pour concevoir un programme en mode graphique

1> Convertir le moniteur d'affichage du mode texte au mode graphique.

Effectuez les opérations graphiques requises comme le remplissage, la coloration, le dessin, etc.
Enfin, fermez le mode graphique et restaurez le mode caractère.

Conversion de caractères en pixels

1. void init gragraph (int *, int *, char *)

Chemin de résolution du pilote de fichier BGI
Ou
Mode
2. Dessin utilisant des fonctions intégrées.
3. void fermer le graph( );
void restaurer_mode_crt();

Programme : - WAP pour couvrir le mode d'affichage du moniteur de caractères à pixels et imprimer
message de bienvenue.

#inclure <graphics.h>
#include <conio.h>
#include <stdlib.h>
vidéo principal()
 {
int gd, gm, ec;
DETECT
Inttgraph (&gd, &gm, "C:\TC\BGI");
Ec= graphresult( );
si (ec!=grOk) ou (ec!=0)
{
Printf("erreur lors de l'initialisation");
sortir(1);
}
Effacer l'appareil
texte de bienvenue ("Bienvenue dans les graphiques");

Getch( );
Fermer le graphique( );

Restarectmode( );
}
Remarque :-

int getmaxx(); renvoie la valeur maximale de la coordonnée x.

int getmaxy( ):- renvoie la valeur minimale de si - coordonnée.

Devoir :- Modifiez le code ci-dessus afin que le code affiche le

Message au nectar de l'écran.

vide principal()
{
int gd, gm, ec;
DÉTECTER
Initgraph (&gd, &gm, "C:\TC\BGI");
Ec=graphresult( );
si (ec ! = grOk)
{
printf ( "erreur" );
sortie(1);
}
EffacerAppareil( );
int a = getmaxx( );
int b = getmaxy( );
Outtextry ( ( a/2), (b/2), "bienvenue dans les graphiques");
Getch( );
 Fermergraph( );
RestaurerModeCRT( );
}

Q. Écrivez un programme pour accepter un nom d'utilisateur puis convertir l'écran en mode graphique et afficher
le nom donné par l'utilisateur au centre de l'écran sur le personnage à la fois.

void main ( )
{
char str[20]
int gd, gm, ec;
DÉTECTER
Initgraph (&gd, &gm, "c:\TC\BGI");
Ec = graphresult( );
si (ec!=grOk)
{
Printf ( "erreur");
sortir(1);
}
Cleardevicl ( ); printf("entrez le nom");
Déplacez-vous vers (getmaxx( ) /2, getmaxy( )/2);
pour (i=0; str[i]; i++)
{
Spritf (msg, "%c", str[i]);
Hors texte (msg);
Délai (1000);
}
}
Changer le style et la taille de la police

[Link] définirStyleTexte (int police, int dir, int tailleCaractère)

description des paramètres

police par défaut

TRIPLEX – POLICE (1)
PETIT – POLICE (2)
SANS – SERIT – FONT (3)
GOTHIQUE – POLICE (4)
SCRIPT – POLICE (5)
SIMPLEX – POLICE (6)
 PRIPLEX – SCRIPT – POLICE (7)
COMPLEXE – POLICE (8)
EUROPEEN – POLICE (9)
GRAS – POLICE (10)

Dir horiz – dir (0)

Vert – dir (1)

1 à 10
1 étant de taille 8 x 8 pixels.

Programme :-
void main( )
{
char * font – style [ ] = { “ Defualt – font” ----, “BOLD-
POLICE" );
int gd, gm, ec; char msg[20];
DETECTER
Initgraph (&gd, &gm, "C: \ TC\ BGI");
Ec = resultatgraph ( );
si (ec ! = 0)
{
printf("erreur");
sortie (1);
}
Cleardevicl ( )
Déplacez-vous vers (getmaxx()/2, getmaxy()/2);
pour (1=0; i<=10; i++)
{
Printf (msg = "shiv - %s", style-de-police [i]);
Définir le style du texte (I, 0, 1);
Outtextry (getmaxx( )/2, getmaxy( )/2, msg);
Getch();
Cleardevicl ( );
}
Cleardevicl( );
Restorecrtdevicl ( );
}

DESSIN EN GRAPHIQUE
1. pour Dessiner une Ligne :-

[Link] ligne (int x1, int y1, int x2, int y2)
[Link] linerel (int, int)
[Link]é ligne à (int, int)

-
void maiN ( )
{
int gd, gm, ec, x, y;
DÉTECTER
Initgraph ( &gd, &gm, " c:\TC\BGI”);
Ec = graphresult( );
si (ec ! = 0)
{
Printf ( "erreur");
sortie (1);
}
Cleardevicl ( );
X=getmaxx( )/2; y=getmaxy( )/2
Ligne (0, 0, x, y);
Getch ( );
Fermergraph( );
Restorertmode( );

[Link] qui trace une ligne de 20, 30 à 100 pixels plus loin et l'affiche.
coordonnée de la ligne à son point d'extrémité.

void main ( )
{
int gd, gm, ec, x, y;
DÉTECTER
Initgraph (&gd, &gm, "c:\TC\BGI”);
Ec = résultatgraph ( );
si (ec! = 0)
{
Printf ( "erreur");
sortie (1);
}
 Cleardericl ( );
Déplacez-vous vers (20, 30);

Sprintf (msg, "%d %d", get x( ), gety( ) );

Texte de sortie (msg);
Linerel (100, 100);
Sprintf (msg, "%d %d", getx( ), gety( ) );
Texte de sortie (msg);
}

Tracer des lignes d'une largeur et d'un style spécifiques

void setline style (int style, int pattern, int thickness)

Pas de constant signification

0 LIGNE SOLIDE ligne solide
1 LIGNE POINTILLÉE
2 LIGNE CENTRALE ligne avec point et tiret
3 LIGNES EN POINTILLÉ ligne avec des tirets
4 USERBIT-LIGNE

C'est toujours zéro sauf lorsque le premier paramètre est la ligne userbit.

Épaississants : ÉPAISSEUR
3 – LARGEUR-NORME

vide principal()
{
int gd, gm, ec, I;
char * style [ ] = { “solidline}, Dotted-line”,----, “Dashedline”};
DÉTECTER
Initgraph ( &gd, &gm, "C:\TC\BGI”);
Ec=graphresult( );
si (ec != grok)
{
Printf ( "erreur");
sortie(1);
}
Deardvice( );
pour (i=0; i<4; i++)
{
 Spritf (msg, "%s en largeur normale", style[i]);
Outtext (getmaxx( )/2-20, getmaxy( )/2-10, msg);
Définir le style de ligne (I,0, LARGEUR-NORM);
Ligne (getmaxx() / 2 - 50, getmaxy() / 2 + 20, getmaxx() / 2 + 50,
Getmaxy( )/2 +100);
Getch( );
Cleardevicl( );
}
Restorectdevicl( );
}

Définir des motifs de manière définie par l'utilisateur

Je définis une ligne de bits utilisateur, nous devons construire un motif de six bits. Dans ce motif
Chaque fois qu'un bit est un, le pixel correspondant dans la ligne est dessiné dans l'actuel
couleur de dessin.
par ex- : 65535
ou
définir le style de ligne (4, OXFFFF, LARGEUR-NORM);
cela tracera une ligne solide,
définir le style de ligne (4, Ox3333, ÉPAISSEUR-NORMALE)
cela tracera une ligne en pointillés.

Tracer des arcs, des cercles ou des rectangles

1. vide arc (int x, int y, int angle de début, int angle de fin, int rad)

2. void piesline (int x, int y, int stangle, int endangle, int rad)

3. void cercle (int x, int y, int rad)

4. vide rectangle (int gauche, int haut, int droite, int bas)
5. void bar (int gauche, int haut, int droit, int bas)

Remplissage d'image avec différents motifs

 void définir couleur (int)
void setfillstyle (int motif, int style)

Le paramètre de motif signifie le motif dans lequel le dépôt doit être fait.
fait.

Nom valeur Résultat

1. Remplissage vide 0 Couleur de fond

2. REMPLISSAGE SOLIDE 1 Remplissage solide

3. FICHIER DE LIGNE 2 --------------

-------------

4. LISLASH_FICHIER 3

5. REMPLISSAGE EN TRANCHE 4

6 FICHIER BKLASH 5

7. LTBKSLASH-FICHIER 6

FICHIER HATCH 7

FICHIER XHATCH 8

FICHIER INTERLEAVE 9

FICHIER À POINTS LARGES

10

FERMER-FICHIER-DOT11

WAP qui dessine un rectangle avec un contour blanc et une couleur de remplissage rouge et doit afficher
le renseignement dans chacun des douze motifs un par un. Le nom du motif devrait également
être affiché dans le rectangle.

vide principal()
{
int gd, gm, ec, gauche, droite, haut, bas, I;
char * style [ ] = { “EMPTY-FILE”, “SOLID-FILE”, ----,
FICHIER-COMPRIMÉ-DOIT}
DÉTECTER
Initgraph (&gd, &gm, "C:\TC\BGI");
Ec=grapgresult();
si (ec !=0)
{
Printf("erreur");
sortie (1);
}
Cleardevicl ( );
Gauche = getmaxx( )/2-100;
Top=getmaxy( )/2-100
Droit - getmaxx( )/2+100;
Bottom=getmaxy( )/2;
pour(i=0; i<12; i++)
{
Définir le style de remplissage (I, ROUGE);
Barre(gauche, haut, droite, bas);
Rectangle (gauche, haut, droite, bas);
Outtextxy (gauche+50, haut+50, style[i]);
}
}

REMPLISSAGE DE CERCLES ET DE TRIANGLES

1. void remplissage (int x, int y, int limite)

(x, y) un point à l'intérieur de la figure qui doit être rempli en utilisant flodfill également connu
si triste.

Couleur de limite :- Couleur à laquelle le remplissage doit s'arrêter.

Remplissage des cercles avec différents motifs

vide principal()
{
char * pattern = { “EMPTY-FILE”, --------, “CLOSE-DOT-FILE”};
int gd, gm, ec, x, y, 0;
 DETECT
Initgraph(&gd, &gm, "C:\TC\BGI");
Ec=graphresult( );
si (ec! = grOk)
{
Printf ( "erreur");
exit(1);
}
EffacerAppareil();
X=getmaxx( )/2; y=getmaxy( )/2;
pour (i=0; i<12; i++)
{
Définir la couleur (VERT);
Cercle (x, y, 100);
Définir le style de remplissage (I, ROUGE);

Remplissage (x, y, GREER);

Définir la couleur (BLANC);

Outtextxy (x-50, y-50, patter[i]);

Getch();
Cleardivice( );
}
Getch ( );
RestaurerDispositifCRT();
}

Stockage et affichage d'images à l'écran

[Link] getline (int, int, int, int, void *)

2. int imagesize (int, int, int, int)
[Link] putimage (int, int, void *, int option)

void getimage (int, int, int, int, void *)

copie l'image bitmap spécifiée
position dans la mémoire

1stle paramètre indique coordonnées de gauche

2etparamètres à “
3rdparamètre droit
4thparamètre bas
5thparamètre pointeur vers un tableau suffisamment grand pour stocker le motif de bits.

void putimage [int x, int y, void * are, int iption)

Copie ou exporte le motif de l'image de la mémoire vers le spécifié
portion à l'écran.

X = coordonnée gauche de départ

Y = coordonnée de départ en haut
Arr = maner une couleur du pixel résultant doit être décidée, en prenant en compte
considération des pixels stockés en mémoire et des pixels affichés à l'écran.

taille d'image int (int, int, int, int);-

Retourne le nombre d'octets nécessaires pour stocker l'image, en cas d'erreur.
retourner -1

void main ( )
{
int gd, gm, ec;
char * tampon, msg [20];
int taille -0f-image;
DÉTECTER
Initgraph ( &gd, &gm, "C:\TC\BGI");
Ec = résultat_du_graphique();
si (ec ! = 0)
{
Printf ("erreur");
quitter (1);
}
Rectangle (150, 150, 200, 200);
taille-de-l'image = taille de l'image (150, 150, 200, 200);
si (taille-de-l'image == -1)
{
Outtextxy (getmaxx( )/2, getmaxy( )/2, "Erreur");
Getch( );
Fermer le graphique();
exit(1);
}
Buffer = (char *) malloc (taille-de-l'image * taille de (char) );
si (le tampon == NULL)
{
 Outtextxy (getmaxx( )/2, getmaxy( )/2, "Impossible d'allouer de la mémoire");
Gecth( );
sortie(1);
Fermer le graphique();
}
Obtenirimage (150, 150, 200, 200, tampon);
Ligne (200, 220, 220, 220);
Mettreimage (175, 200, tampon, COPIER-METTRE);
Getch( );
Fermeturegraph();
Restaurer crtdevice( );
}

VALEURS ÉCRAN EMORY SORTIE

COPIER-PLACER SUR ON SUR
DÉSACTIVÉ SUR SUR
SUR ÉTEINT DÉSACTIVÉ
DÉSACTIVÉ DÉSACTIVÉ HORS

XOR-PLACER SUR SUR DÉSACTIVÉ

DÉCONNECTÉ SUR SUR
SUR DÉSACTIVER SUR
DÉSACTIVÉ DÉSACTIVÉ DÉSACTIVÉ

OR-METTRE ON SUR SUR

DÉSACTIVÉ SUR SUR
SUR DÉCONNECTÉ SUR
DÉSENGAGÉ DÉSENGAGÉ ÉTEINT

ET-METTRE SUR SUR SUR

DÉSENGAGÉ SUR ÉTEINT
SUR DÉCONNECTÉ DÉCONNECTÉ
DÉCONNECTÉ DÉSACTIVÉ DÉSACTIVÉ

LA FIN