MaClasse *BonObjet, *MauvaisObjet;
       
MauvaisObjet = malloc(sizeof(MaClasse)); // alloue de la mémoire mais n'appelle pas le constructeur
BonObjet = new MaClasse; // alloue de la mémoire et appelle le constructeur.
         

int * tableau = new int[ 10] ; // alloue un tableau de 10 entiers

delete [] tableau; // ATTENTION : ne pas oublier les crochets []

int * tableau = new int[ 10 ];
delete [] tableau;

delete [] mesObjets ; // libère le tableau mesObjets

#include <algorithm> // pour fill_n

// créer un tableau d'entiers à 2 dimensions [ 10 ][ 20 ]
const int dim1 = 10; // taille de la dimension 1
const int dim2 = 20; // taille de la dimension 2
int dim_allouee = 0; // nombre d'éléments alloués avec succès sur la dimension 2
int * * Tab = 0;
// tenter d'allouer la taille demandée dim1 x dim2
try
{
    // dimension 1 : tableau de 10 pointeurs vers des tableaux d'entiers
    Tab = new int * [ dim1 ];
    // initialiser les 10 pointeurs à 0 (NULL)
    std::fill_n( Tab, dim1, static_cast<int*>( 0 ) );

    // dimension 2 : les tableaux d'entiers
    for ( dim_allouee = 0; dim_allouee < dim1; ++dim_allouee)
    {
        Tab[ dim_allouee ] = new int[ dim2 ];
    }
}
catch ( const std::bad_alloc & ) // erreur d'allocation
{
    // désallouer tout ce qui a été alloué avec succès
    for ( int i = 0; i < dim_allouee; ++i ) 
    {
        delete [] Tab[ i ];
    }
    delete [] Tab;
}

int** Tab;
int i;

for(i=0; i<10; i++) {
    delete [] Tab[i];
}

delete []Tab;

#include <iostream>

int Tab[50];
std::cout << sizeof(Tab) / sizeof(int); // affiche "50"

template<typename T, size_t N>
inline size_t length_of(T(&)[N])
{
    return N;
}

template <std::size_t N>
struct array {char value[N];};

template<typename T, std::size_t N>
array<N> length_of_helper(T (&)[N]);

#define length_of(array) (sizeof length_of_helper(array).value)

#include <iostream>

int* Tab = new int[50];
std::cout << sizeof(Tab); // affiche "4"

#include <iostream>
#include <vector>

std::vector<int> Tab(50);
std::cout << Tab.size(); // affiche "50"

void* raw = allocate(sizeof(Foo));  // ligne 1
Foo* p = new(raw) Foo();            // ligne 2 
 

class Pool
{
public:
    void* alloc(size_t nbytes);
    void dealloc(void* p);
private:
    // données membres...
};
 
void* Pool::alloc(size_t nbytes)
{
   // code d'allocation
}
 
void Pool::dealloc(void* p)
{
   // code de libération
} 
 

Pool pool;
// ...
void* raw = pool.alloc(sizeof(Foo));
Foo* p = new(raw) Foo(); 
 

Foo* p = new(pool.alloc(sizeof(Foo))) Foo(); 
 

inline void* operator new(size_t nbytes, Pool& pool)
{
   return pool.alloc(nbytes);
} 
 

new(pool) Foo() 
 

void sample(Pool& pool)
{
   Foo* p = new(pool) Foo();
   // ...
   p->~Foo();     // appel explicite du destructeur
   pool.dealloc(p);  // libération explicite de la mémoire
} 
 

Foo* p;
 
// ne pas intercepter les exceptions lancées par l'allocateur 
void* raw = operator new(sizeof(Foo));
 
// intercepter toute exception lancée par le constructeur 
try {
    p = new(raw) Foo();  // appel du constructeur avec 'raw' comme pointeur 'this'
} catch (...) {
    // le constructeur a lancé une exception
    operator delete(raw);
    throw;  // relancer l'exception du constructeur
 } 
 

void* raw = operator new(sizeof(Foo), pool);
// cette fonction renvoie simplement  "pool.alloc(sizeof(Foo))"
 
Foo* p = new(raw) Foo();
// si la ligne précédente provoque une exception, pool.dealloc(raw) n'est PAS appelée
 

new(pool) Foo()
 

void operator delete(void* p, Pool& pool)
{
   pool.dealloc(p);
} 
 

Foo* p;
 
// ne pas intercepter les exceptions lancées par l'allocateur
void* raw = operator new(sizeof(Foo), pool);

// le code précédent renvoie simplement "pool.alloc(sizeof(Foo))"
 
// intercepter toute exception lancée par le constructeur 
try {
   p = new(raw) Foo();  // appel du constructeur avec raw en tant que this
} catch (...) {
   // le constructeur lance une exception
   operator delete(raw, pool);  // la ligne "magique"
   throw;  // relance l'exception
} 
 

void operator delete(void* p)
{
    if (p != NULL) {
        Pool* pool = /* quelqu'un qui détient le 'Pool*' associé */;
        if (pool == null)
            free(p);
        else
            pool->dealloc(p);
    }
} 
 

void* operator new(size_t nbytes)
{
   if (nbytes == 0)
     nbytes = 1;  // chaque alloc obtient donc une adresse différente
   void* raw = malloc(nbytes);
   // ... associer le Pool* à Null a 'raw'...
   return raw;
} 
 

<void*,Pool*>
 

void* operator new(size_t nbytes)
{
   if (nbytes == 0)
     nbytes = 1;                    // ainsi toutes les allocations possèdent une adresse distincte
   void* ans = malloc(nbytes + 4);  // on alloue 4 bytes supplémentaires
   *(Pool**)ans = NULL;             // on utilise NULL pour le new global
   return (char*)ans + 4;           // on cache le Pool* à l'utilisateur
}
 
void* operator new(size_t nbytes, Pool& pool)
{
   if (nbytes == 0)
     nbytes = 1;                       // ainsi toutes les allocations possèdent une adresse distincte
   void* ans = pool.alloc(nbytes + 4); // on alloue 4 bytes supplémentaires
   *(Pool**)ans = &pool;           // stocker le Pool* ici
   return (char*)ans + 4;              // on cache le Pool* à l'utilisateur
}
 
void operator delete(void* p)
{
   if (p != NULL) {
     p = (char*)p - 4;              // on récupère le Pool*
     Pool* pool = *(Pool**)p;
     if (pool == null)
       free(p);                     // note: 4 bytes de moins que le p original
     else
       pool->dealloc(p);         // note: 4 bytes de moins que le p original
   }
} 
 

#include <new>       // On doit inclure <new.h> pour utiliser "placement new"
#include "Fred.h"      // Déclaration de la classe  Fred
    
void someCode()
{
    char memory[sizeof(Fred)];      // Ligne 1
    void* place = memory;           // Ligne 2
    
    Fred* f = new(place) Fred();    // Ligne 3 (voir "DANGER" ci-dessous)
     // Les deux pointeurs f et  place sont maintenant égaux
}

 

void someCode()
{
   char memory[sizeof(Fred)];
   void* p = memory;
   Fred* f = new(p) Fred();
   // ...
   f->~Fred();    // Appel explicite au destructeur
}
 

// Test1 est exception safe sans utilisation de pointeur intelligent
void Test1()
{
    int * ptr = new int;
    try
    {
        // code pouvant lever une exception
    }
    catch ( ... ) // gestion approximative...
    {
        // libérer le pointeur
        delete ptr;
        // relancer l'exception
        throw;
    }
    // tout s'est bien passé, libérer la mémoire
    delete ptr;
}

#include <memory> // pour std::auto_ptr

// Test2 est exception safe en utilisant un pointeur intelligent
void Test2()
{
    // std::auto_ptr est la classe pointeur intelligent standard
    std::auto_ptr<int> smart_ptr = new int;

    // code pouvant lever une exception (rien d'autre !)
}

int Test() 
{ 
    // ptr1 est le propriétaire
    std::auto_ptr<int> ptr1( new int );
    {
        // ptr2 devient le propriétaire
        std::auto_ptr<int> ptr2 = ptr1;
    }
    // ici ptr2 est détruit, le int est libéré !
    // ptr1 pointe désormais vers NULL
    *ptr1 = 10; // aille aille aille...
}

include <memory> 

// Ptr est passé par valeur, donc a priori aucun risque que le
// paramètre donné lors de l'appel ne soit modifié
void Test( std::auto_ptr<MaClasse> Ptr ) 
{ 
    // Mais ce qui va réellement se passer, c'est que Ptr va prendre
    // le contrôle de l'objet pointé, et le détruire à la fin de la fonction ! 
} 

MaClasse* Ptr1 = new MaClasse; 
Test( std::auto_ptr<MaClasse>( Ptr1 ) ); 
// Ici Ptr1 ne pointe plus sur une zone valide, il a été détruit suite à l'appel 

std::auto_ptr<MaClasse> Ptr2( new MaClasse ); 
Test( Ptr2 ); 
// Ici Ptr2 ne pointe plus sur la donnée originale
// il pointe sur NULL et la donnée a été détruite dans la fonction 

// Enregistre un fichier donné dans la base de données
// lève une exception en cas d'échec
void WriteFileInDatabase( DataBase & Db, std::string Filename )
{
    // tenter d'ouvrir le fichier
    Datafile file;
    if ( !file.Open( Filename ) )
    {
        // impossible d'ouvrir le fichier...
        throw InvalidArgument();
    }
    // verrouiller la base de données
    if ( !Db.Lock() )
    {
        // on ne peut pas utiliser la base...
        throw DatabaseError();
    }
    // écrire le fichier dans la base
    Db.WriteData( file.ReadData() );

    // tout s'est bien passé : libérer les ressources
    Db.Unlock();
    file.Close();   
}

// Enregistre un fichier donné une la base de donnée
// lève une exception en cas d'échec
void WriteFileInDatabase( DataBase & Db, std::string Filename )
{
    // tenter d'ouvrir le fichier
    Datafile file;
    if ( !file.Open( Filename ) )
    {
        // impossible d'ouvrir le fichier...
        throw InvalidArgument();
    }
    // verrouiller la base de données
    if ( !Db.Lock() )
    {
        // fermer le fichier
        file.Close();
        // on ne peut pas utiliser la base...
        throw DatabaseError();
    }
    // écrire le fichier dans la base
    try
    {
        Db.WriteData( file.ReadData() );
    }
    catch ( ... )
    {
        // libérer les ressources en cas d'erreur
        Db.Unlock();
        file.Close();
        throw; // relancer l'exception
    }
    // tout s'est bien passé : libérer les ressources
    Db.Unlock();
    file.Close();   
}

struct DBLock
{
    DBLock(DataBase& DB) : DB_(DB)
    {
        DB_.Lock();
    }

    ~DBLock()
    {
        DB_.Unlock();
    }

private :

    DataBase& DB_;
};

void WriteFileInDatabase( DataBase & Db, std::string Filename )
{
    // ouvrir le fichier
    Datafile file( Filename );
    // fichier ouvert : vérrouiller la base
    DBLock lock( Db );
    // base verrouillée : écrire les données du fichier
    Db.WriteData( file.ReadData() );
} // libération des ressources automatiques