Sorry your browser is not supported!

#include <stdlib.h>
#include <stdio.h>

long incremente();
long point();

int TabAlloc();


int main(int argc, char *argv[])
{
    TabAlloc();
    printf("%ld\n", incremente());
    printf("%ld\n", incremente());
    printf("%ld\n", incremente());
    printf("%ld\n", incremente());

    //printf("Valeur du tableau :%ld",Array2D[55][74]);
    printf("Pointeur :%ld",fff);
    return 0;
}

long incremente()
{
    static long nombre = 0;

    nombre++;
    return nombre;
}

long point()
{
    static long fff = 5689;

    fff++;
    return fff;
}

int TabAlloc()
{
    // allocation
    int nbL = 530;
    int nbC = 1024;

    static long arrayPointer = 0;//NULL;

    int ** Array2D = (int **)malloc(nbL*sizeof(int));

    for(int i = 0; i < nbL; ++i)
    {
        Array2D[i] = (int *)malloc(nbC*sizeof(int));
    }

    //arrayPointer = &Array2D;

    return nbL;
}

#define nbL 530
#define nbC 1024

int Array2D[nbL][nbC]

template <typename Content>
class Array2D
{
private:
    typedef std::vector<Content> InnerVector;
    typedef std::vector<InnerVector> VectorArray;

public:
    typedef unsigned int IndexType;

    Array2D() : Width(0), Height(0)
    { }

    Array2D(int Width_, int Height_)
        : Width(Width_), Height(Height_), Array( Width_, InnerVector(Height_))
    { }

    typename VectorArray::reference operator[](IndexType Index)
    {
        return Array[Index];
    }

    typename VectorArray::const_reference operator[](IndexType Index) const
    {
        return Array[Index];
    }

    IndexType GetWidth() const { return Width; }
    IndexType GetHeight() const { return Height; }
private:
    IndexType Width;
    IndexType Height;
    VectorArray Array;
};

#include <iostream>

int main()
{
    Array2D<int> MyArray(10, 10);
    int CellCount = 0;

    for (Array2D<int>::IndexType y = 0; y < MyArray.GetHeight(); ++y)
    {
        for (Array2D<int>::IndexType x = 0; x < MyArray.GetWidth(); ++x)
        {
            MyArray[x][y] = CellCount;
            ++CellCount;
        }
    }

    for (Array2D<int>::IndexType y = 0; y < MyArray.GetHeight(); ++y)
    {
        for (Array2D<int>::IndexType x = 0; x < MyArray.GetWidth(); ++x)
        {
            std::cout << MyArray[x][y] << ", ";
        }
        std::cout << '\n';
    }
}

Array2D<int> Arena;

void SetSize(int Width, int Height)
{
    Arena = Array2D<int>(Width, Height);
}

#ifndef __myClass
#define __myClass

/// This class impliments a Singleton Design

class myClass
{

	private:
		/// our singelton tracking variable
		static myClass* instance;

		/// constructor that can only be called by getInstance()
		myClass();

		/// A value to modify in the class
		int testVal;

	public:
		/// get the singleton Instance of this class
		static myClass* getInstance(){
			if(instance == NULL) instance = new myClass;
			return instance;
		}

		/// destructor
		~myClass();

		/// Set the test value
		void setVal(int val);

		/// Get the test value
		int getVal();

};

#endif

#include "myClass.h"

// initialize the instance to be nothing
myClass* myClass::instance = NULL;

// Constructor
myClass::myClass(){
	testVal = 0;
}

// Destructor
myClass::~myClass(){
}

// Set the test value
void myClass::setVal(int val){ testVal = val; }

// Get the test value
int myClass::getVal(){ return testVal; }

#include <stdio.h>
#include "myClass.h"

void printIt();

int main(){
	// Somewhere in your program where you want to get a pointer to the object
	myClass* mc = myClass::getInstance();

	// set the test value
	mc->setVal(100);

	printIt();
}


// some other function to get and print the value
void printIt(){

	myClass* mcPtr = myClass:getInstance();

	printf("Val: %d", mcPtr->getVal());

}

template <class T>

class Singleton
{
   static T *getInstance(){
        T singleton;
        return &singleton;
   }
};

class MyClass : public Singleton<MyClass>
{
  ...
};

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


// allocation
int nbrL = 530;
int nbrC = 1024;

int ** Array2D = (int **)malloc(nbrL*sizeof(int));
void AllocArrays(void)
{
    int v = 0;

    for(v = 0; v < nbrL; v++)
    {
        Array2D[v] = (int *)malloc(nbrC*sizeof(int));
    }
}


void ReallocArrays(int nbl, int nbc);

int main()
{
    AllocArrays();
    Array2D[10][14] = 512;
    printf("Valeur de la case (10,14) du tableau : %ld n",Array2D[10][14]);
    system("PAUSE");
    printf("Reallocation en cours...n");

    ReallocArrays(253,169);

    Array2D[56][169] = Array2D[10][14];
    printf("Valeur originale (10,14) :%ld et valeur nouvelle(56,169) : %ld n",Array2D[10][14],Array2D[56][169]);

    system("PAUSE");
    free(Array2D);

    return 0;

}

void ReallocArrays(int nbl, int nbc)
{
    //reallocation
    int nbL = nbl;
    int nbC = nbc;

    Array2D = (int**)realloc(&Array2D,nbL*sizeof(int));

    for(int i = 0; i < nbL; ++i)
    {
        Array2D[i] = (int *)malloc(nbC*sizeof(int));
    }

}

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


// allocation
int nbrL = 530;
int nbrC = 1024;

int ** Array2D = (int **)malloc(nbrL*sizeof(int));
void AllocArrays(void)
{
    int v = 0;

    for(v = 0; v < nbrL; v++)
    {
        Array2D[v] = (int *)malloc(nbrC*sizeof(int));
    }
}


void ReallocArrays(int nbl, int nbc);

int main()
{
    AllocArrays();
    Array2D[10][14] = 512;
    printf("Cell (10,14) value of Array2D : %ld n",Array2D[10][14]);
    system("PAUSE");
    printf("Reallocating...n");

    ReallocArrays(253,169);

    Array2D[56][169] = Array2D[10][14];
    printf("First value of cell (10,14) :%ld and new value of cell (56,169) : %ld n",Array2D[10][14],Array2D[56][169]);

    system("PAUSE");
    free(Array2D);

    return 0;

}

void ReallocArrays(int nbl, int nbc)
{
    //reallocation
    int nbL = nbl;
    int nbC = nbc;

    Array2D = (int**)realloc(&Array2D,nbL*sizeof(int));

    for(int i = 0; i < nbL; ++i)
    {
        Array2D[i] = (int *)malloc(nbC*sizeof(int));
    }

}