Matriz estática vs. matriz dinâmica em C ++

Qual é a diferença entre uma matriz estática e uma matriz dinâmica em C ++?

Eu tenho que fazer uma tarefa para minha classe e diz para não usar arrays estáticos, apenas arrays dinâmicos. Procurei no livro e online, mas não pareço entender.

Achei que a estática foi criada em tempo de compilação e dinâmica em tempo de execução, mas posso estar confundindo isso com alocação de memória.

Você pode explicar a diferença entre array estático e array dinâmico em C ++?

Os arrays locais são criados na pilha e têm duração de armazenamento automática - você não precisa gerenciar a memória manualmente, mas são destruídos quando a função em que estão encerrados. Eles têm necessariamente um tamanho fixo:

int foo[10];

Os arrays criados com operator new[]têm duração de armazenamento dinâmico e são armazenados no heap (tecnicamente, o "armazenamento gratuito"). Eles podem ter qualquer tamanho, mas você mesmo precisa alocá-los e liberá-los, pois não fazem parte do quadro de pilha:

int* foo = new int[10];
delete[] foo;

static é uma palavra-chave em C e C ++, portanto, em vez de um termo descritivo geral, static tem um significado muito específico quando aplicado a uma variável ou array. Para aumentar a confusão, ele tem três significados distintos em contextos separados. Por causa disso, uma matriz estática pode ser fixa ou dinâmica.

Deixe-me explicar:

O primeiro é específico do C ++:

• Um membro de classe estático é um valor que não é instanciado com o construtor ou excluído com o destruidor. Isso significa que o membro deve ser inicializado e mantido de alguma outra maneira. O membro estático pode ser ponteiros inicializados como nulos e então alocados na primeira vez que um construtor é chamado. (Sim, isso seria estático e dinâmico)

Dois são herdados de C:

• dentro de uma função, uma variável estática é aquela cuja localização na memória é preservada entre as chamadas de função. É estático porque é inicializado apenas uma vez e retém seu valor entre as chamadas de função (o uso de estática torna uma função não reentrante, ou seja, não threadsafe)

• variáveis ​​estáticas declaradas fora das funções são variáveis ​​globais que só podem ser acessadas de dentro do mesmo módulo (arquivo de código-fonte com qualquer outro # include)

A questão (eu acho) que você quis fazer é qual a diferença entre arrays dinâmicos e arrays fixos ou em tempo de compilação. Essa é uma pergunta mais fácil, os arrays de tempo de compilação são determinados antecipadamente (quando o programa é compilado) e fazem parte de um quadro de pilha de funções. Eles são alocados antes da execução da função principal. arrays dinâmicos são alocados em tempo de execução com a palavra-chave "new" (ou a família malloc de C) e seu tamanho não é conhecido com antecedência. as alocações dinâmicas não são limpas automaticamente até que o programa pare de ser executado.

Eu acho que a semântica sendo usada em sua aula é confusa. O que provavelmente se entende por 'estático' é simplesmente "tamanho constante", e o que provavelmente se entende por "dinâmico" é "tamanho variável". Nesse caso, uma matriz de tamanho constante pode ter a seguinte aparência:

int x[10];

e um "dinâmico" seria qualquer tipo de estrutura que permite que o armazenamento subjacente seja aumentado ou diminuído no tempo de execução. Na maioria das vezes, a std::vectorclasse da biblioteca padrão C ++ será suficiente. Use-o assim:

std::vector<int> x(10); // this starts with 10 elements, but the vector can be resized.

std::vectorfoi operator[]definido, para que você possa usá-lo com a mesma semântica como uma matriz.

Matrizes estáticas são alocadas na memória em tempo de compilação e a memória é alocada na pilha. Considerando que, os arrays dinâmicos são alocados memória no tempo de execução e a memória é alocada do heap.

int arr[] = { 1, 3, 4 }; // static integer array.   
int* arr = new int[3]; // dynamic integer array.

É importante ter definições claras do significado dos termos. Infelizmente, parece haver várias definições do que significam os arrays estáticos e dinâmicos.

Variáveis ​​estáticas são variáveis ​​definidas usando alocação de memória estática . Este é um conceito geral independente de C / C ++. Em C / C ++, podemos criar variáveis ​​estáticas com escopo global, de arquivo ou local como este:

int x[10]; //static array with global scope
static int y[10]; //static array with file scope
foo() {
    static int z[10]; //static array with local scope

Variáveis ​​automáticas são geralmente implementadas usando alocação de memória baseada em pilha . Uma matriz automática pode ser criada em C / C ++ assim:

foo() {
    int w[10]; //automatic array

O que esses arrays, x, y, ze wtêm em comum é que o tamanho de cada um deles é fixo e definido em tempo de compilação.

Uma das razões pelas quais é importante entender a distinção entre um array automático e um array estático é que o armazenamento estático é geralmente implementado na seção de dados (ou seção BSS ) de um arquivo de objeto e o compilador pode usar endereços absolutos para acessar os arrays o que é impossível com armazenamento baseado em pilha.

O que geralmente significa um array dinâmico não é aquele que pode ser redimensionado, mas um implementado usando alocação de memória dinâmica com um tamanho fixo determinado em tempo de execução. Em C ++, isso é feito usando o newoperador .

foo() {
   int *d = new int[n]; //dynamically allocated array with size n     

Mas é possível criar uma matriz automática com um tamanho de correção definido em tempo de execução usando alloca:

foo() {
    int *s = (int*)alloca(n*sizeof(int))

Para um verdadeiro array dinâmico, deve-se usar algo como std::vectorem C ++ (ou um array de comprimento variável em C ).

O que significava a atribuição na pergunta do OP? Acho que está claro que o que se queria não era um array estático ou automático, mas um que usasse alocação de memória dinâmica usando o newoperador ou um array de tamanho não fixo usando, por exemplo std::vector.

Acho que, neste contexto, significa que é estático no sentido de que o tamanho é fixo. Use std :: vector. Ele tem uma função resize ().

Você poderia ter uma matriz pseudo dinâmica em que o tamanho é definido pelo usuário em tempo de execução, mas é corrigido depois disso.

int size;
cin >> size;
int dynamicArray[size];

Matriz estática :

1. Matrizes estáticas são alocadas na memória em tempo de compilação.
2. O tamanho é fixo.
3. Localizado no espaço de memória da pilha.
4. Por exemplo. : int array [10]; // array de tamanho 10

Matriz dinâmica:

1. A memória é alocada em tempo de execução.
2. O tamanho não é fixo.
3. Localizado no espaço de memória Heap.
4. Por exemplo. : int * array = new int [10];

Sim, certo, o array estático é criado no momento da compilação, enquanto o array dinâmico é criado no tempo de execução. No que diz respeito à diferença, no que diz respeito às localizações de memória, os estáticos estão localizados na pilha e os dinâmicos são criados no heap. Tudo o que fica localizado na pilha precisa do gerenciamento de memória até e a menos que o coletor de lixo, como no caso da estrutura .net, esteja presente, caso contrário, há o risco de vazamento de memória.

Matriz estática: Eficiência. Nenhuma alocação dinâmica ou desalocação é necessária.

Matrizes declaradas em C, C ++ em função, incluindo modificador estático, são estáticas. Exemplo: static int foo [5];

estática arrary meens com distribuição de elementos ao lado da matriz

arrary meens dinâmicos sem ceder elementos ao lado da matriz

exemplo:

     char a[10]; //static array
       char a[];  //dynamic array