Pourquoi dans un tableau "int" les adresses des valeurs vont de 4 en 4?

sizeof int

In octet or in word ?

c'est quoi sizeof int ?

Ce que je comprends pas ce que dans le tuto il est dit : [B]chaque case mémoire contient un octet c'est-à-dire huit bits[/B] donc j'en conclus qu'un "int" (4 octets) contient 4 cases et c'est la 1ere cases qui contient l'adresse et c'est pour cela que les adresse vont de 4 en 4..

C'est ça ou pas?

Non.

Soit a l'adresse de départ.
Pour avoir l'adresse au premier élément, d'indice 0, tu vas le récupérer à l'adresse : a + 0 * sizeof int, donc à l'adresse a.
Le second élément, d'indice 1, se situe à l'adresse a + 1 * sizeof int, donc a+4 sur ta machine+ton compilateur (attention : sizeof int varie selon les architectures et les implémentations).
Etc.

Donc, pour accéder à l'élément i, tu vas le chercher à l'adresse :
a + i * sizeof int
C'est exactement ce que fait la syntaxe : a[ i ].

Un "tableau" ne connait donc que deux informations : son adresse de départ, et le type d'éléments stockés (ici, "int", ce qui permet de faire "sizeof int" et donc de savoir combien de bytes prend un élément).
C'est pourquoi en C, le nombre d'éléments doit être conservé à part, aucune sécurité n'empêchant d'accéder à un élément d'indice arbitrairement grand, et dépassant la capacité de stockage de ton tableau.

Merci mais j'ai pas compris.. et oui c'est pas facile d'être débutant..
 
Peut tu inexpliqué plus facilement ?
 
Merci d'avance...

Ton adresse va de 4 en 4 parce qu'il faut 4 bytes pour stocker un int (encore une fois, sur TON architecture actuelle).

Un tableau, c'est juste une adresse de début, et un type de données.
Pour accéder à une donnée à l'indice i, il faut ajouter i * la taille d'une donnée à l'adresse de début pour y accéder.

Tiens, un petit code écrit à l'arrache, pour te montrer :

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int a[] = {13, 42, 27, 53, 34};
    const unsigned aSize = sizeof(a) / sizeof(int);
 
    for(unsigned i = 0; i  < aSize; ++i)
        printf("Elément %d : %d\n", i, *(int*)((void*)a + i * sizeof(int)));
 
    return 0;
}

Ce qui nous donne bien :

Et schématiquement, ça donne ça :

En plus court : une adresse pointe sur un octet, un int fait 4 octets, dont les ints se trouvent tous les 4 octets, donc les adresses de ceux si vont de 4 en 4.

C'est un pointeur qui pointe.
Soit p un pointeur. p vaut une certaine valeur, qui est une adresse, celle de ce qui est pointé par p.
Si p est un pointeur sur des char, p+1 a pour valeur la valeur de p plus 1, car la taille de d'un char est 1 (octet). Bref, p+1 pointe sur le char suivant celui pointé par p, et comme la taille d'un char est 1, l'adresse de ce char suivant est l'adresse du char pointé par p, plus 1.
Si p est un pointeur sur des int, p+1 a pour valeur la valeur de p plus 4, car la taille de d'un int est 4 (octets). Bref, p+1 pointe sur l'int suivant celui pointé par p, et comme la taille d'un int est 4, l'adresse de cet int suivant est l'adresse de l'int pointé par p, plus 4.  
Attention a ne pas se faire avoir par l'écriture: p+1 ne vaut pas nécessairement la valeur de p (ie l'adresse de ce qui est pointé par p) auquel on ajoute 1. p+1, c'est l'adresse de ce qui est juste après ce qui est pointé par p. Donc ca dépend de la taille de ce qui est pointé par p.
Quand le compilo voit une déclaration X* p; et que plus tard, il voit p+n, il remplace en interne l'expression p+1 par la valeur p+n*sizeof(X) pour avoir la valeur de l'adresse
A+,

Illustré, dans le bout de code ci-dessus, par le cast de mon tableau en "void*" pour pouvoir faire mon addition d'adresse (j'aurais dû le préciser)

Il galère déjà à comprendre comment la mémoire est organisée, pas la peine de partir là-dedans.

Mais de là dire qu'une adresse pointe sur un octet, ça risque de le confusifier encore plus, non?