Declaration d'un tableau en langage C

char *tableau; /* un pointeur */
tableau = malloc(sizeof(char)*20); /* on demande 20 char en mémoire */
/* tableau prend alors pour valeur l'adresse retournée par malloc */
if(tableau!=NULL) /* si l'opération à réussi tableau contient l'adresse des 20char  (l'adresse du premier bloc de la taille du type***) */
{
    /* alors on peut utiliser tableau comme un simple tableau ici par exemple */
}

#include <stdio.h>
#include <stdlib.h>

int main(void)
  {
    char *tab=malloc(sizeof(char)*4); /* tab à l'adresse du premier bloc de la taille d'un char */
    tab+=sizeof(char); /* incrémente d'un char l'adresse contenu dans tab */
    *tab='x'; /* met la lettre x dans l'emplacement */
    tab-=sizeof(char); /* décrémente d'un char l'adresse contenu dans tab */
    *tab='z'; /* y met un z */
    printf("%s\n",tab);
    free(tab);
    return 0;
  }

#include <stdio.h>
#include <stdlib.h>
/*****
  Exemple simplifié de tableau à grossissement automatique en C
  Date de création : 4 juillet 2011.
**/
typedef struct 
{
  int taille;
  long *elements;
  int taille_Grossissement;
} TableauDeLongs;

void affecterTableauDeLongs(TableauDeLongs *tab,long valeur, int index);

int main()
{
  TableauDeLongs montableau = {0, 0, 10}; // Mon tableau "intelligent" (si on l'aide un peu)
  // faire une boucle de saisie de nombre entiers et les mettre dans un tableau auto grossissant en C 
  printf("Saisir autant de nombres (entiers long) que souhaité : arrêt si on rentre le nombre 9999\n");
  long unnombre = 0;
  int indexsuivant = 0;
  do
  {
     printf("Saisir un nombre à mettre das le tableau : ");
	 scanf("%ld",&unnombre);
	 affecterTableauDeLongs(&montableau, unnombre, indexsuivant);
	 ++indexsuivant; // pour le prochain
  }
  while (unnombre != 9999);
  printf("Voici la liste des saisies stockées dans le tableau rangées par 5\n");
  int i,j;
  for (i = 0,j = 0;i < indexsuivant;++i,++j)
  {
      printf("\t%ld", montableau.elements[i]);
	  if (j < 4)
	  {
	    printf(", ");
	  }
	  else
	  {
	    j = -1;
	    printf("\n");
	  }
  }
}
// Gestion en C d'un grossissement de tableau "automatique" : l'index part de 0
void affecterTableauDeLongs(TableauDeLongs *tab,long valeur, int index)
{
  if (index < 0)
  {
    fprintf(stderr, "*****index negatif interdit*********\n");
	return;
  }
  printf("\nDemande affecter tableau[%d]\n", index);
  if (index >= tab->taille)
  {
     int nouvelle_taille;
     // calcul de la nouvelle taille en multiple de la taille de grossissement (on aurait pu utiliser la fonction ceil(), mais bon
     int nombre_unites = (index + 1)/tab->taille_Grossissement;
	 if (((index + 1) % tab->taille_Grossissement) != 0) nombre_unites += 1;
	 nouvelle_taille = nombre_unites * tab->taille_Grossissement;
	 printf("\n>>>>>>>>>Augmentation de la taille du tableau de %d à %d\n",tab->taille, nouvelle_taille);
	 // nouvelle allocation mémoire et récup des anciens éléments
	 // on pourrait utiliser realloc, mais ça me parait plus clair comme ça, et en plus on peut initialiser à 0 les nouvelles valeurs
	 long *nouveau_elements = calloc(nouvelle_taille,sizeof(long));
	 memset(nouveau_elements,0,nouvelle_taille * sizeof(long)); // met des 0 partout
	 memcpy(nouveau_elements, tab->elements, tab->taille*sizeof(long)); // copie de l'ancien tableau
	 if (tab->taille > 0)
	 {
	    free(tab->elements);
	 }
	 tab->elements = nouveau_elements; // remplace le tableau
	 tab->taille = nouvelle_taille;
  }
  tab->elements[index] = valeur;
}