Muitos elementos em uma matriz!

StackOverflow https://stackoverflow.com/questions/795194

  •  18-09-2019
  •  | 
  •  

Pergunta

Desculpe se isso é uma questão de noob :(.

pedaço de código C. 

int array[5];
int cnt;

for(cnt = 0; cnt <= 10; cnt+=1)
{
      array[cnt] = cnt;
}

Deve dar um erro, certo? Não! Funciona bem! Mas por que isso? Parece que -no primeiro linha- ??uma matriz de mais do que o dobro do tamanho (11) é definida. Você pode até mesmo matriz de Acesso [5-10] mais tarde. E isso está me confundindo. Ele pára de funcionar quando você define array [4 ou menos] ...

Agradecemos antecipadamente.

Foi útil?

Solução

Pode acontecer de trabalho com o seu compilador e computador específico, mas você não deve contar com isso.

O comportamento do seu código de acordo com a especificação da linguagem C é indefinido . Isso significa que ele pode fazer o que você espera, ou pode causar uma pane no computador, ou ele pode causar demônios para voar para fora seu nariz .

Ao contrário de linguagens de alto nível como Java e C #, trusts C você e não executar verificações explícitas sobre os limites de arrays. Você é suposto ser responsável e não pisar fora dos limites da matriz.

Outras dicas

Isto apenas "obras" se a sua definição de "obras" é sinônimo de "não caiu ainda."

O que você está vendo é comportamento indefinido , causada por você acessar a matriz com um índice inválido. meios comportamento indefinido que qualquer coisa pode acontecer, incluindo o seu programa aparecendo para o trabalho corretamente.

"Mas por que isso?"

Porque essa é a forma C é.

limites de matriz não são verificados em tempo de execução.

Essa é a "Lei da C"

Eu só gostaria de salientar que tudo isto é realmente indefinida. Seu exemplo "funciona" neste exemplo específico, porque ambas as variáveis ??estão localizados na pilha. Esse é o endereço do cnt é logo abaixo do final da matriz. Quando chega cnt cnt == 5 a matriz comunicado [CNT] = cnt; não escreve na memória dedicada para a matriz, mas apenas depois dele, onde o endereço do cnt leigos. É apenas sorte que ele não altera seu contador. Quando cnt> 5 não há memória para o lixo e ele vai escrever no "pilha vazia" (não sei a palavra adequada).

outro exemplo para ilustrar isso: 

int main(int ac,char **av)
{
    int a[5];
    int cnt;
    int cnt2=3;

    for(cnt=0;cnt<7;cnt++) {
        a[cnt]=cnt;
        printf("%d %d %d\n", a[cnt], cnt, cnt2);
    }
}

saída: 

0 0 3
1 1 3
2 2 3
3 3 3
4 4 3
5 5 5
6 6 5

As duas últimas gravações do circuito substitui os dados da pilha após a [] e pode resultar em erros muito confuso. Neste caso, o CNT2 é um lixo.

Arrays em C não são verificados em tempo de execução. Em outras palavras, você pode "definir" uma matriz de tamanho N e felizmente acessar off do final da matriz ligada. Se você sair no final do array, então você irá lixo em algum lugar da memória na pilha (ou pilha).

Uma vez que o lixo em algum lugar da memória, o programa é susceptível de acidente. Estes acidentes podem ser difíceis de rastrear, porque eles podem falhar longe de onde você realmente overran o final da matriz.

Normalmente, quando você declarar matrizes em C, é melhor usar algum tipo de constante ou #define para marcar o tamanho da matriz: 

#define MAX_ELEMENTS 10
int array[MAX_ELEMENTS];
int cnt;
for(cnt = 0; cnt < MAX_ELEMENTS; cnt+=1) {
   array[cnt] = cnt;
}

Se você vai MAX_ELEMENTS últimos na atribuição de matriz, você pode substituir o valor de cnt. Você pode substituir alguma outra variável. Tudo depende do compilador e a estrutura de código. Observe também o uso do

limites matriz em C são não necessariamente verificado em tempo de execução. As folhas padrão implementadores libertar a fazê-lo se quiserem, ou não - que é parte do que é indefinido . Em uma implementação com ponteiros de gordura da amostra poderia realmente causar algum tipo de erro.

Uma vez que você correr para fora da extremidade da matriz, você está substituindo memória que o software não está esperando e corrompendo o heap. Você software pode continuar a funcionar, mas vai ser muito instável!

Depende de como a memória de pilha é embalado. Além disso, felizmente irá substituir esses valores e até mesmo lê-los, mas muito provavelmente você está corrompendo a pilha.

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