Adresse d'une variable statique lors de la création de l'instance

Question

J'ai une classe C++ qui a une constante statique et une variable statique. Au démarrage, j'initialise toutes les variables const statiques avec certaines valeurs de chaîne et toutes les variables statiques avec des zéros.

Ensuite, je crée la première instance de cette classe et j'ai essayé de modifier la variable statique seule. Ensuite, j'ai créé la 2ème instance de la même classe et essayé d'écrire une autre valeur autre que celle que j'ai écrite pour la 1ère instance. Plus tard, lorsque j'ai essayé d'accéder à la variable statique de la 1ère instance, elle contient les valeurs de la 2ème instance. tout en regardant dans l'emplacement de la mémoire, j'ai trouvé l'adresse du pointeur variable sont les mêmes pour les deux instances.

Est-ce quelque chose que j'ai écrit à tort?

Mon extrait de code:

#include "stdafx.h" 
#include <time.h> 
#include <stdlib.h> 

CBase::CBase(const myStruct *myStructPtr) { 
    initStruct(myStructPtr); 
} 

CBase::~CBase() {} 

void CBase::initStruct(const myStruct *myStructPtr) { 
    m_myStructPtr = const_cast<myStruct *>(myStructPtr); 
    if (m_myStructPtr) { 
     uint8_t nNumDatas = (m_myStructPtr->numOfOutputs) ? (m_myStructPtr->numOfOutputs - 1) : 0; 
     if (nNumDatas) { 
      for (int idx = 0; idx < m_myStructPtr->numOfOutputs - 1; idx++) { 
       if (m_myStructPtr->someNumber[idx]) 
        m_myStructPtr->someNumber[idx] = (unsigned int)rand(); 
      } 
     } 
    } 
} 

void CBase::printSomeNumber() { 

if (m_myStructPtr) { 
    uint8_t nNumDatas = (m_myStructPtr->numOfOutputs) ? (m_myStructPtr->numOfOutputs - 1) : 0; 
    if (nNumDatas) { 
     for (int idx = 0; idx < m_myStructPtr->numOfOutputs - 1; idx++) { 
      printf("\n printing : name %s, print number : 0x%x", m_myStructPtr->someName[idx],m_myStructPtr->someNumber[idx]); 
     } 
    } 
} 
} 

const char * CDerived::scm_acsomeName[] = { "INIT", "REQ", NULL }; 
unsigned int CDerived::sm_aunsomeNumber[] = { 0, 0xDEADBEEF }; 

const myStruct CDerived::myDerivedStruct = { 
    3, scm_acsomeName, sm_aunsomeNumber 
}; 

int main() 
{ 
    CBase *FirstDerived = new CDerived(); 
    CBase *SecondDerived = new CDerived(); 

FirstDerived->printSomeNumber(); 
SecondDerived->printSomeNumber(); 
while (1); 
return 0; 
} 

Mon fichier d'en-tête:

#include <stdint.h> 
#include <string> 
#include <iostream> 

struct myStruct { 
    uint8_t numOfOutputs; 
    const char **someName; 
    unsigned int *someNumber; 
}; 

class CBase 
{ 
public: 
    CBase(const myStruct *myStructPtr); 
    virtual ~CBase(); 
    void printSomeNumber(); 
private: 
    CBase(const CBase&); 
    void initStruct(const myStruct *myStructPtr); 

protected: 
    const myStruct* m_myStructPtr; 
}; 

class CDerived : public CBase { 
private: 
    static const myStruct myDerivedStruct; 
    static const char *scm_acsomeName[]; 
    static unsigned int sm_aunsomeNumber[]; 

public: 
    CDerived() : CBase(&myDerivedStruct) {} 
    virtual ~CDerived() {} 
}; 

message d'impression de la console:

printing : name INIT, print number : 0x0 
printing : name REQ, print number : 0x4823 
printing : name INIT, print number : 0x0 
printing : name REQ, print number : 0x4823 

Answer 1

Est-ce quelque chose que j'ai écrit à tort?

Non, c'est exactement ainsi que fonctionnent les membres de données statiques. Vous obtenez une instance par classe.