Pergunta

Esse problema me envolveu sem saber o suficiente de C ++. Estou tentando acessar um valor específico que coloquei na pilha, mas não tenho certeza de como acessá -lo. No meu problema, eu havia colocado um valor em uma pilha de uma função de membro de dados em um objeto e estou tentando acessá -lo em outra função de membro de dados. O problema é que eu não sei como e procurei exemplos on -line, mas nenhum era o que eu precisava, pois estavam todos em int main () e não eram especificamente o que eu precisava.

Na primeira função do membro de dados, declaro o valor que quero ser enviado para o heap; Aqui está um exemplo do que minha primeira função de membro de dados.

void Grid::HeapValues()
{
    //Initializing Variable
    value = 2; //The type is already declared

    //Pointers point a type towards the Heap
    int* pValue = new int;

    //Initialize  an a value of in the Heap
    *pValue = value;
}

E na função de membro de dados, é isso que deseja:

void Grid::AccessHeap()
{
    //Extracting heap:
    int heap_value = *pValue; //*pValue does not exist in this function
    cout << heap_value; //Delays the value 2, which is found
                        //in the first data member function
}

Sinto -me tolo por perguntar, mas não consigo encontrar as respostas e não como. Alguém sabe como acessar um valor da pilha de uma maneira simples? E eu precisaria que ele pudesse acessar em mais de duas função de membro de dados.

Foi útil?

Solução

O PValue precisa ser uma variável de membro da grade de classe.

class Grid
{
  private: int* pValue;
  public: void HeapValues();
          void AccessHeap();
};

Agora, o PValue de variável de membro está acessível a partir de qualquer função de membro da grade.

Outras dicas

Não se esqueça de excluir seu ponteiro no destruidor quando terminar. Para mais informações visite:

Como Aaron disse que você pode tornar o valor um membro da sua classe de grade. Nesse caso, embora não haja necessidade de ser um ponteiro para um int.

class Grid
{
private:

    int value;

public:

    void HeapValue();
    void AccessHeap();
};

O valor será armazenado como parte do objeto onde quer que seja instanciado. Você pode fazer isso na pilha ou na pilha, isso não importa. Para valores simples, como os tipos e objetos incorporados que pertencem à instância da classe, é desnecessário alocá -los usando novos. Dessa forma, você não precisa se preocupar em limpar com o operador de exclusão no destruidor da grade, apenas certifique-se de descartar a instância da rede própria corretamente ;-)

De grossa, há exceções a isso que você aprenderá à medida que se aprofundará mais no C ++, mas para o seu exemplo, o acima estará bem.

Por que você quer isso na pilha? Se você adicioná -lo como parte da classe, estará no mesmo local em que a classe estará, possivelmente na pilha ou na memória global. Talvez você queira ter um tamanho variável para o seu ponteiro inteiro? Nesse caso, você precisa ter certeza de negociar a memória quando terminar.

O problema com as coisas na pilha é encontrá -lo. Não há como acessar o nome, a menos que você adicione um mecanismo para isso. De alguma forma, você precisa comunicar o local a qualquer código que precise acessá -lo. Nesse caso, parece que você só precisa de acesso na classe Grid, por isso é fácil. Basta torná -lo uma variável de membro como Aaron indica. Você pode acabar com algo como:

class Grid
{
protected:
    int* pVals;
public:
    Grid() pVals(NULL) { }
    ~Grid() { delete [] pVals; }
    void HeapValues() {
        pVals = new int[getHeapValuesSize()];
        pVals[0] = 1; // ...
    }
    void AccessHeap() {
        cout << pVals[0]; // ...
    }

(Em uma nota lateral, você parece estar usando a frase "Função do membro de dados" quando você quer dizer "função do membro". "Membro de dados" refere -se aos dados do membro de uma classe, como PVals, mas não tenho certeza de quais "dados A função de membro "significaria.)

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top