Heap e Stack quando usar cada uma



  • Existem algumas situações que definem quando algo deve ser mandado para heap ou stack.
    Tempo de vida que uma variável ou objeto deve ter, Alocação dinâmica quando não podemos prever qual será o tamanho de uma variável, e também objetos muito grandes que ocupam muita memória.

    Eu ainda me confundo bastante quanto a ultima situação, ou seja, objetos muito grandes. Como julgar se um objeto é ou não grande demais para a stack? Nesse código por exemplo:

    @QHash DataAccess::readSettings()
    {
    QSettings connecsettings( QSettings::IniFormat, QSettings::SystemScope, "Freedom", "TecTracker");

    QHash<QString, QVariant> parameter;

    connecsettings.beginGroup("Connection");

    if(!connecsettings.contains("host"))
    writeSettings(&connecsettings);

    parameter.insert("host", connecsettings.value("host", "127.0.0.1"));
    parameter.insert("port", connecsettings.value("port", 5432);
    parameter.insert("database", connecsettings.value("database"));
    parameter.insert("user", connecsettings.value("user", "postgres"));
    parameter.insert("passw", connecsettings.value("passw", "postgres"));

    connecsettings->endGroup();

    return parameter;
    }@

    Eu não sei se connecsettings é um objeto grande ou não, consequentemente também não sei se ele deveria ir para a heap:

    @QSettings* connecsettings = new QSettings( QSettings::IniFormat, QSettings::SystemScope, "Freedom", "TecTracker");@

    Ele não precisa durar mais do que o tempo da função, mas não sei quanto ao seu tamanho, se ele é ou não um objeto grande para stack.

    Em um tópico antigo que fiz aqui, alguém também informou que não era uma boa prática alocar muita coisa na stack. Mas como faço esse controle? Como fazer o policiamento para saber se eu estou abusando da stack?



  • Exotic_Devel, vejamos:

    Os compiladores c/c++ utilizam funções complexas para determinar o tamanho da stack, isso quando ele não determina um valor fixo. Depende de parâmetros de compilação, plataforma, etc.

    Stack: Este tipo de memória armazena todas as variáveis ​​locais e as chamadas de função feitas em um programa.

    @void funcao() //funcao executa na stack
    {
    //alocação na stack
    MyClass obj;
    }@

    Heap: Usado em caso de alocações dinâmicas (alloc, malloc, new...).

    @void funcao() //funcao executa na stack
    {
    //alocação na heap.
    MyClass *obj=new MyClass(); //o ponteiro na stack e a instância do bojeto na heap

    delete obj;
    }@

    Outro exemplo são os std:vector:

    Irá alocar as informações do cabeçalho vector na stack, e os elementos na heap.
    @vector <Tipo> vect;@

    Aloca tudo na heap.
    @vector <Tipo> * vect = new vector <Tipo>;@

    Em meus projetos costumo colocar 'arrays e objetos complexos...' na heap, sendo assim, com alocação dinâmica. Objetos únicos, mais simples, sempre na stack. OBS: membros de uma classe são alocados no mesmo segmento de memória do seu dono.



  • bq. Em meus projetos costumo colocar ‘arrays e objetos complexos…’ na heap, sendo assim, com alocação dinâmica. Objetos únicos, mais simples, sempre na stack. OBS: membros de uma classe são alocados no mesmo segmento de memória do seu dono.

    O que seria objetos únicos mais simples? Meu problema está em fazer esse jugamento. Objetos QSetting são simples? Como saber?



  • bq. Objetos únicos, mais simples, sempre na stack.

    Até escrevi de forma bem literal porque é relativo a cada projeto. Um objeto simples para um projeto, pode não ser em outro. Por exemplo, para mim objeto único é um objeto que possuí configurações globais, geralmente membro alocado na classe principal do programa. Um objeto complexo é um objeto que possuí muitos membros ou muitos métodos. Entendeu, é relativo demais.

    Via de regra:

    • Heap: alocações dinâmicas com malloc, new): arrays, vetores etc.
    • Stack: variaveis locais.

    Pergunto: no teu projeto QSetting será acessado globalmente, o mesmo em vários objetos? Então faz alocação faz dinâmica (QSetting *st=new QSetting();) : HEAP. QSetting será utilizado em uma função especifica, uma outra vez,(QSetting st;) então local: STACK.


Log in to reply
 

Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.