Discussion :

[white_fire]

salut a vous tous, j'ai une petite question qui me tracasse depuis pas mal de temps, est-ce qu'on peux savoir si un objet a été crée ou non, s'il existe déjà dans la mémoire et comment on peux le savoir ?
s'il y a une idée comment le faire je suis preneur.

[ram-0000]

Tu veux un compteur d'instances ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class CMaClass
{
public:
CMaClass() { m_nb_instance++; }
~CMaClass() { m_nb_instance--; }
 
static int NbInstance() { return m_nb_instance; }
 
private:
static int m_nb_instance;
};

A chaque fois que ta classe est instanciée, le constructeur de la classe incrémente la variable membre statique m_nb_instance, à chaque fois qu'elle est détruite, le destructeur décrémente le compteur d'instances. La fonction statique NbInstance() te retourne le nombre d'instance à un instant donné.

C'est l'idée de base

[white_fire]

et si je veux tester pour que je sache s'il existe ou non ? c'est faisable ?

[poukill]

Pourquoi tu veux savoir s'il existe?
Si c'est pour être sur de manipuler une donnée valide, alors la réponse c'est : utilise des shared_ptr.
Il implémente un compteur de référence comme ce montre ram-0000 ci dessus. Utilisé en combinaison avec weak_ptr, tu peux gérer presque n'importe quoi avec...

A consommer sans modération.

[koala01]

Salut,

Pourrais tu être un peu plus explicite dans ce que tu veux obtenir

En effet, en toute logique, lorsque tu déclares une variable d'un type donné, cette variable est automatiquement créée en mémoire, et tu peux y accéder au départ de la variable que tu as déclaré.

La variable est d'un autre coté automatiquement détruite (et la mémoire qui lui est dédiée libérée) lorsque tu quitte la portée dans laquelle la variable a été déclarée

Dés lors, il n'y a normalement pas nécessité de s'interroger sur ce point

En effet:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int main()
{
    /* je déclare une variable de type Type, je SAIS
     * qu'un espace mémoire suffisant pour en contenir l'intégralité
     * est réservé à cette variable
     */
    Type mavar;
    /* Tant que je ne passerai pas par l'accolade fermante, je peux
     * accéder aux informations contenues par mavar
     */
} /* mavar est détruite ici et la mémoire qui lui était dévolue est 
   * libérée
   */

L'exception vient de l'utilisation de pointeurs, qu'il est préférable d'initialiser à NULL si, pour une raison ou une autre, nous souhaitons "postposer" l'allocation de la mémoire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
int main()
{
    /* Comme je décale l'allocation de la mémoire (et donc la création de la
     * variable), j'initialise le pointeur à NULL
     */
    Type* pointer=NULL;
    /* la variable pointée existera à partir du moment où j'aurai explicitement
     * demandé l'alloctation de la mémoire
     */
    pointer = new Type;
    /* et existera jusqu'à ce que je demande explicitement la libération
     * de la mémoire... Il ne faudra pas oublier, par sécurité, de remettre
     * le pointeur à NULL
     */
    /* entre temps, nous pouvons nous assurer que pointeur pointe sur une
     * variable (supposée) existante par un simple test proche de
     */
    if(pointer ) /* si tu préfère l'écriture longue ca donne if(pointer !=NULL) */
    {
        /* ce qui doit être fait avec pointer */
    }
    delete pointer;
    pointer = NULL
}

Autrement, il y a moyen de compter le nombre d'instances de la manière présentée par ram-0000 (tu peux à tout moment obtenir le nombre d'instances existantes en invoquant CMaClass::NbInstance() ), voire, veiller à n'autoriser qu'une et une seule instance d'une classe donnée en la transformant en singleton, ou... une foule d'autres possibilités...

Mais, à défaut d'expliquer clairement ce que tu souhaites faire, il nous sera difficile de t'indiquer comment y arriver