Banque d'exemples C++

#include <cstdio>
#include <cstdlib>
#include <ctime>

int COUNT;
#define foreach  for(int i=0; i<COUNT; i++)

void remplisAlea(int *tab)
{
    foreach
        tab[i] = (rand()%200)-100;
}

void copyTab(int *t1, int *t2)
{
    foreach
        t1[i] = t2[i];
}

void printTab(int *t)
{
    foreach
        printf("%d, ", t[i]);
    printf("\n");
}

void swap(int &x, int &y) {
    int t=x;
    x=y; y=t;
}

// O(n²)
void triabulles(int *T)
{
    bool change;
    do
    {
        change = false;
        for(int i=1; i<COUNT; i++)
        {
            if(T[i] < T[i-1]) {
                swap(T[i], T[i-1]);
                change = true;
            }
        }
    } while (change);
}

// O(n²)
void triabullesOpti(int *T)
{
    int max = COUNT;
    while(max > 0)
    {
        int temp = 0;
        for(int i=1; i<max; i++)
        {
            if(T[i] < T[i-1]) {
                swap(T[i], T[i-1]);
                temp = i+1;
            }
        }
        max = temp;
    }
}

// O(n²)
void triCocktail(int *T)
{
    bool change;
    bool inverse = true;
   
    do
    {
        inverse = !inverse;
        change = false;
       
        if(inverse)
        {
            for(int i=COUNT-1; i>1; i--)
            {
                if(T[i] < T[i-1]) {
                    swap(T[i], T[i-1]);
                    change = true;
                }
            }
        }
        else
        {
            for(int i=1; i<COUNT; i++)
            {
                if(T[i] < T[i-1]) {
                    swap(T[i], T[i-1]);
                    change = true;
                }
            }
        }
    } while (change);
}

// O(n²)
void triCocktailOpti(int *T)
{
    int min=1, max=COUNT;
    bool inverse = true;
   
    while(max > 0 && min < COUNT)
    {
        inverse = !inverse;
       
        if(inverse)
        {
            int temp = COUNT;
            for(int i=max-1; i>min; i--)
            {
                if(T[i] < T[i-1]) {
                    swap(T[i], T[i-1]);
                    temp = i-1;
                }
            }
            min = temp;
        }
        else
        {
            int temp = 0;
            for(int i=min; i<max; i++)
            {
                if(T[i] < T[i-1]) {
                    swap(T[i], T[i-1]);
                    temp = i+1;
                }
            }
            max = temp;
        }
    }
}

// O(n²)
void triInsertion(int *T)
{
    for(int i=1; i<COUNT; i++)
    {
        int x = T[i], j = i;
        while(j>0 && T[j-1]>x)
        {
            T[j] = T[j-1];
            j--;
        }
        T[j] = x;
    }
}

// O(n log(n))
void triapeigne(int *T)
{
    int intervalle = COUNT;
    bool change = false;
   
    while(intervalle > 1 || change)
    {
        intervalle = int(intervalle / 1.3f);
        if(intervalle < 1)
            intervalle = 1;
       
        change = false;
        int i=0;
        while(i < COUNT - intervalle)
        {
            if(T[i] > T[i + intervalle]) {
                swap(T[i], T[i + intervalle]);
                change = true;
            }
            i++;
        }
    }
}

void tamiser(int *T, int noeud, int n)
{
    int k = noeud, j = 2*k;
    while(j <= n)
    {
        if(j < n && T[j] < T[j+1])
            j++;
           
        if(T[k] < T[j])
        {
            swap(T[k], T[j]);
            k = j;
            j = 2*k;
        }
        else
            break;
    }
}
// O(n log(n))
void triParTas(int *T)
{
    for(int i = COUNT / 2; i >= 0; i--)
        tamiser(T, i, COUNT-1);
       
    for(int i = COUNT-1; i >= 1; i--)
    {
        swap(T[i], T[0]);
        tamiser(T, 0, i-1);
    }
}

// O(n log(n))
void triRapide(int *T, int deb, int fin)
{
    int gauche = deb-1;
    int droite = fin+1;
    int pivot = T[deb];
   
    if(deb < fin)
    {
        for(;;)
        {
            do droite--; while(T[droite] > pivot);
            do gauche++; while(T[gauche] < pivot);
           
            if(gauche < droite)
                swap(T[gauche], T[droite]);
            else
                break;
        }
        triRapide(T, deb, droite);
        triRapide(T, droite+1, fin);
    }
}
void triRapide(int *T)
{
    triRapide(T, 0, COUNT-1);
}
   
void fusion(int *T, int *A, int *B, int deb, int mil, int fin)
{
    for(int i=0; i<=mil-deb; i++)
        A[i] = T[deb+i];
    for(int i=0; i<=fin-mil-1; i++)
        B[i] = T[mil+1+i];
   
    int iA=0, iB=0, iT=deb;
    while(iA<=mil-deb && iB<=fin-mil-1)
    {
        if(A[iA] < B[iB])
            T[iT++] = A[iA++];
        else
            T[iT++] = B[iB++];
    }
    while(iA<=mil-deb)
        T[iT++] = A[iA++];
    while(iB<=fin-mil-1)
        T[iT++] = B[iB++];
}
// O(n log(n))
void triFusion(int *T, int *A, int *B, int deb, int fin)
{
    if(deb < fin)
    {
        int mil = (deb + fin)/2;
        triFusion(T, A, B, deb, mil);
        triFusion(T, A, B, mil+1, fin);
        fusion(T, A, B, deb, mil, fin);
    }
}
void triFusion(int *T)
{
    int *A = new int[COUNT/2+1];
    int *B = new int[COUNT/2+1];
    triFusion(T, A, B, 0, COUNT-1);
    delete[] A;
    delete[] B;
}


int compare(const void * x, const void * y) {
    return ( *(int*)x - *(int*)y );
}
void triStd(int *T) {
    qsort(T, COUNT, sizeof(int), compare);
}

void tri(int *T, int *tab, void (*f) (int *))
{
    f(T);
    printTab(T);
    copyTab(T, tab);
}

void perfs(int *T, int *tab, const char *str, void (*f) (int *))
{
    clock_t start = clock();
    f(T);
    printf("%s: %f\n", str, ((float)clock() - start) / CLOCKS_PER_SEC);
    copyTab(T, tab);
}

int main()
{
    srand(time(NULL));
   
    COUNT = 15;
    int *tab = new int[COUNT];
    int *T  = new int[COUNT];
    remplisAlea(tab);
    copyTab(T, tab);
   
    printTab(tab);
    tri(T, tab, triabulles);
    tri(T, tab, triabullesOpti);
    tri(T, tab, triapeigne);
    tri(T, tab, triInsertion);
    tri(T, tab, triParTas);
    tri(T, tab, triRapide);
    tri(T, tab, triStd);
    tri(T, tab, triFusion);
   
    qsort(T, COUNT, sizeof(int), compare);
    printTab(T);
    copyTab(T, tab);
   
    delete[] tab;
    delete[] T;
   
   
    // Performances
    COUNT = 10000;
    tab = new int[COUNT];
    T  = new int[COUNT];
    remplisAlea(tab);
    copyTab(T, tab);
   
    printf("\nTris sur %d elements.\n", COUNT);
    perfs(T, tab, "Tri a Bulles", triabulles);
    perfs(T, tab, "Tri a Bulles Opti", triabullesOpti);
    perfs(T, tab, "Tri Cocktail", triCocktail);
    perfs(T, tab, "Tri Cocktail Opti", triCocktailOpti);
    perfs(T, tab, "Tri a Peigne", triapeigne);
   
    delete[] tab;
    delete[] T;
   
   
    COUNT *= 1000;
    tab = new int[COUNT];
    T  = new int[COUNT];
    remplisAlea(tab);
    copyTab(T, tab);
   
    printf("\nTris sur %d elements.\n", COUNT);
    perfs(T, tab, "Tri a Peigne", triapeigne);
    perfs(T, tab, "Tri par Tas", triParTas);
    perfs(T, tab, "Tri Rapide", triRapide);
    perfs(T, tab, "Tri Rapide libstd", triStd);
    perfs(T, tab, "Tri Fusion", triFusion);
   
    delete[] tab;
    delete[] T;

    return 0;
}

class MaClasse {
    MonMembre& refMembre;
}

public class MaClasse {
private MaClasseMembre monMembre;
}

class MaClasse
{
    public:
    MonMembre& refMembre;
    MaClasse(MonMembre& Obj);
}

MaClasse::MaClasse(MonMembre& Obj) : refMembre(Obj)        // <----- Ici l'initialisation de la référence
{
   
}

#include <iostream>

#include <boost/cstdint.hpp>
#include <boost/make_shared.hpp>
#include <boost/typeof/typeof.hpp> // Pour BOOST_AUTO

struct Position {
    Position(int32_t x, int32_t y) : x(x), y(y) {}
    virtual ~Position() {
        std::cout << *this << " est détruit." << std::endl;
    }

    int32_t x;
    int32_t y;

    friend std::ostream& operator<<(std::ostream &os, const Position &pos) {
      os << "Position x,y :" << pos.x << "," << pos.y << " ";
      return os;
    }
};

class Pixel {
    public:
        Pixel() {};
        virtual ~Pixel() {
            std::cout << "Le pixel est détruit" << std::endl;
        };

        void draw() {
            if (m_pos.get() != NULL) { // Etant donné qu'il est possible à que ce soit NULL il faut le vérifier
               
                // Les shared_ptr fonctionnent comme de vrais pointeur avec plus de fonctionnalité:
                // pour le déréférencer et avoir l'objet pointé il suffit de fair *m_pos, et donc le raccourci : -> pour accèder à un membre fonctionne également.
                std::cout << "drawPoint(" << m_pos->x << "," << m_pos->y << ")" << std::endl;
            }
        }

        void pos(boost::shared_ptr<Position> pos) {
            m_pos = pos;
        }

        boost::shared_ptr<Position> pos() const {
          return m_pos;
        }

  private:
      boost::shared_ptr<Position> m_pos;
};

int main(int argc, char **argv) {
 
    {
        BOOST_AUTO(monPixel, boost::make_shared<Pixel>()); // Simplement pour m'évitier d'écrire: boost::shared_ptr<Pixel> monPixel(new Pixel());

        {
            BOOST_AUTO(maPosition, boost::make_shared<Position>(0,0)); // Simplement pour m'évitier d'écrire: boost::shared_ptr<Position> maPosition(new Position(0,0));

            std::cout << "Entrez la position x :" << std::endl;
            std::cin >> maPosition->x;
            std::cout << "Entrez la position y :" << std::endl;
            std::cin >> maPosition->y;


            std::cout << "Une position particulière : " << *maPosition << std::endl;
           
            monPixel->pos(maPosition);
        }

        monPixel->draw();
        // Ici maPosition continue à exister puisque monPixel a un shared_ptr vers ce dernier.
    }

    // Ici monPixel est supprimé puisque personne ne le référence plus, comme c'est le cas en java avec le garbage collector, sauf qu'avec les smart ptr c'est du reference counting, ça veut dire qu'un objet ne sera pas gardé un certain temps avant d'être jeté de la mémoire, et qu'il n'y a pas de thread supplémentaire qui gère la mémoire, c'est juste beau : quand le compte d'utilisateur du shared_ptr est à 0 c'est viré de la mémoire.

    // En conséquence l'objet référencé par monPixel, càd maPosition, est également supprimé de la mémoire, étant donné que plus personne n'a de référence.

  return 0;
}

template <typename T, std::size_t N>
std::size_t size(T(&)[N]) { return N; }

// C++03
boost::array<int, 6> arr;
arr.size();

// C++11
std::array<int,6> arr,
arr.size();