Mémo rapide sur le C++

Mots-clé: c++, commande, instruction, memo, cpp

Pour sortir un truc:

std::cout << "position: x=" << std::endl

DECLARATION DANS .H
Dans la déclaration du fichier en .h
virtual= méthode d'instance (pas obligatoire)
static=méthode statique
const= méthode ne modifiant pas les variables membres, mettre après le nom de la fonction membres ( virtual int getX() const; )

DECLARATION DANS .CPP
Déclaration dans le CPP:
On sépare le nom de la classe et le nom de la fonction avec :: (il en ait de même pour le nom du namespace)

Pour les instanciations:
Opérateur :: = méthode de classe (à utiliser pour les méthodes statiques)
Opérateur -> = méthode d'instance (à utiliser seulement pour une instance)

INSTANCES
Deux façons de manipuler des instances de classes:
Manipuler des objets:
Déclaration:

NomClasse NomInstance

Acces aux membres:

NomInstance.NomMembre

Manipuler des références vers les objets:
Déclaration:

NomClasse* NomInstance

Accès aux membres:

NomInstance->NomMembres

L'opérateur *. est équivalent à ->

Après chaque instanciation, il ne faut pas oublier de supprimer l'objet en faisant: delete NomDeLObjet.
En écrivant de plus, NomDeLObjet = 0 ou NULL on est sûr de vider l'espace mémoire associé.

STRUCT
struct = class sauf que tous les membres sont publics.

HERITAGES:
Declaration:
class NomClasse: public NomClasseMere
L'heritage multiple est possible en C++.


INLINE:
Ce mot est à utiliser lorsqu'on implémente une fonction dans le .H

CLASSES ABSTRAITES:
Il n'est pas nécessaire de préciser l'abstraction par un mot clé du genre ABSTRACT mais toutes les méthodes doivents être virtuelles pures cad en ajoutant le mot clé VIRTUAL.

TABLEAU
Déclaration d'un tableau d'objets:

TypeARanger NomDuTableau[] = new TypeDuTableau[Taille]

Déclaration d'un tableau de référence:

TypeARanger* NomDuTableau[] = new TypeDuTableau*[Taille]

Attention il faut détruire le tableau en érivant:

delete[] NomDuTableau

CONST
Const signifie que ce qui est suivi est constant.

const char* s1 = "abcd";        // valeur pointee constante
char* const s2 = "abcd";        // pointeur constant (NB: INCORRECT dans ce cas!)
const char* const s3 = "abcd";  // les deux

REFERENCES
Pointeurs qui références des adresses d'objets mais il s'agit de constantes. Une référence pointe toujours vers la même adresse.
Le but de la référence est de permettre de transmettre des arguments de fonction sous forme d'adresses.
Déclarations:

TypeReference& NomReference = *new Constructeur;
Circle& c = *new Circle(50, 200);   // #1
c.setX(15);                         // #2

Lorsqu'on ecrit:

int* p = &i1;                 // p pointe sur i1. &i1 est l'adresse.
cout << "p=" << *p << "\n";   // il faut une * puisque p est une adresse
  int& r2 = i2;                 // r2 référence i2
  cout << "r2=" << r2 << "\n";  // il ne faut pas d' *

  int& r1 = *p;                 // r1 référence *p c'est-a-dire i1
  cout << "r1=" << r1 << "\n";

  p = &r2;                      // p référence l'objet pointé par r2 cad. i2
  cout << "p=" << *p << "\n";

  r1 = r2;                      // !!!!!
  cout << "r1=" << r1 << "\n";
  cout << "i1=" << i1 << "\n";  // que constate-t'on ?