Estrutura de Dados

[felipecesar 0]

typedef struct nolista {
  int dado;
  int d;
  struct nolista *prox;
}no;

 

feito essa estrutura para lista encadeada eu criei uma função para localizar o endereço de memoria de cada variável criada.

 

void funcao() {
  struct nolista d;
  struct nolista d1;
  struct nolista d2;
  struct nolista d3;
  struct nolista d4;
  printf("%p", &d);
  printf("\n%p", &d1);
  printf("\n%p", &d2);
  printf("\n%p", &d3);
  printf("\n%p", &d4);
}

 

o resultado foi o seguinte:

 

0022FF30

0022FF20

0022FF10

0022FF00

0022FEF0

 

A minha duvida: Se eu declarar 2 inteiros, e cada inteiro tem 4 bytes vai ser a mesma coisa que se eu declarar 3 inteiros. No total vai ficar 16 bytes.

 

4 bytes de um inteiro + 4 bytes de outro inteiro + um ponteiro da estrutura 4+4=8, no final, fica: 4+4+8=16.

 

Sabendo que um inteiro pode ser também 2 bytes, então ele divide 2 bytes para cada inteiro? tipo se eu declarar 3 inteiros na estrutura.

 

typedef struct nolista {
  int dado;
  int d;
  int o;
  struct nolista *prox;
}no;

 

4 bytes de um inteiro + 2 bytes de outro inteiro + 2 bytes de outro inteiro + um ponteiro da estrutura 4+2+2=8, no final, fica: 4+2+2+8=16. Eu acho que ele faz isso automaticamente para economizar a memoria.

 

Alguém pode me explicar como funciona isso? E porque os endereços esta na ordem decrescente?

 

Obrigado

[guidjos 65]

A forma como a implementação (leia 'compilador' ou 'interpretador') organiza os objetos em memória não é importante, a não ser quando se trata de 'partes' de uma mesma array. Mesmo neste caso, não se costuma usar os valores numéricos, e sabe-se apenas (e isto é suficiente) que os elementos têm posições consecutivas e adjacentes, e podem ser acessados usando aritmética de ponteiros.

 

O tamanho de cada tipo de dados depende da implementação. A linguagem define valores limitantes inferior e superior para os valores máximo e mínimo (respectivamente) de cada tipo. Exemplo: int deve ser capaz de representar o máximo valor mínimo INT_MIN, que deve ser menor ou igual a -32767. Analogamente, há INT_MAX, que deve ser maior ou igual a 32767. Estes limites estão em limits.h.

 

Quanto ao conceito de byte, até nisso há flexibilidade. Em C, um byte é o tamanho de um char. A quantidade de bits que compõem um byte é maior ou igual a 8. O tamanho dos outros tipos de dados é sempre um múltiplo do tamanho de um char. Portanto, em C, um byte pode ter mais de 8 bits. Em implementações de PDPs e alguns IBMs, bytes tinham 9 bits e ints, 36 (4 bytes). Portanto, quando sizeof te diz quantos bytes seu operando tem, não assuma que há esta quantidade x 8 bits.

 

Quanto à posição adjacente dos seus objetos em memória, há uma footnote relevante na seção 6.5.10:

 

Two objects may be adjacent in memory because they are adjacent elements of a larger array or

adjacent members of a structure with no padding between them, or because the implementation chose

to place them so, even though they are unrelated.

 

O que não muda é o tamanho de um tipo em uma mesma implementação (ou seja, todos os chars têm o mesmo tamanho, assim como todos os ints, floats, etc).

 

O tamanho de uma struct pode ser maior que a soma dos tamanhos dos seus elementos, pois pode haver padding bits, que não são contabilizados por sizeof.

[felipecesar 0]

então deve ter ocorrido o padding bits ;D ... Porque eu peguei o sizeof de struct nolista quando eu tinha declarado apenas dois inteiros e um ponteiro da própria struct e ele retornou 12. Já com 3 inteiro foi retornado 16. O endereço hexadecimal continuou o mesmo para ambos, acredito que teve o padding bits no primeiro caso então.