C Ansi

Le C ANSI est généralement le dialecte le plus portable est compatible avec le plus grand nombre de machines et compilateurs. Le C++ en est une surcouche à
quelques différence près .

Nouveautés depuis le C K&R

Apportées depuis le C++

Les commentaires d’une ligne //.

Le C originel n’acceptait que les commentaires multiligne de type /* commentaire */.

Fonctions a prototype

Les fonctions a prototype permettent de caster automatiquement les arguments des appels de fonction. Ici la fonction sqrt attend une variable de type double et on doit faire le cast nous même.

// Source - https://stackoverflow.com/a
// Posted by Jonathan Leffler
// Retrieved 2026-01-03, License - CC BY-SA 3.0

#include <stdio.h>

double sqrt();

main(argc, argv)
    char **argv;
{
    if (argc > 1)
        printf("sqrt(%s) = %f\n", argv[1], sqrt((double)atoi(argv[1])));
    else
        printf("sqrt(%.0f) = %f\n", 2.0, sqrt(2.0));
    return 0;
}

En connaissant les signatures des differentes fonctions on peut faire l’économie de casts

// Source - https://stackoverflow.com/a
// Posted by Jonathan Leffler
// Retrieved 2026-01-03, License - CC BY-SA 3.0

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

int main(int argc, char **argv)
{
    if (argc > 1)
        printf("sqrt(%s) = %f\n", argv[1], sqrt(atoi(argv[1])));
    else
        printf("sqrt(%.0f) = %f\n", 2.0, sqrt(2));
    return 0;
}

Les variables et fonctions sont cosidérées comme etant de type int lorsqu’il n’y a pas d’ambiguité possible.

Il est possible de compiler le programme suivant ainsi gcc -ansi -w code.c

/// code.c
*g; // pointeur sur int
// les variables globales sont externes par defaut

main(argc, argv, argp) 
// argc est cosidéré comme "int" par defaut
char *argv[];
char *argp[];
{
    auto foo = 42; // auto rend "int" optionnel, et vice-versa

    g = &foo;

    printf("%d\n", *g); // 42
    puts("hello"); // pas besoin d'include "stdio", 
    // la liaison se fait en incluant la libc dans 
    // l'executable final, ce que gcc 
    // fait automatiquement.
}

Les enumerations.

Différences avec le C K&R

Le C Ansi consière que les arguments d’une fonction ont la même portée que les variables déclarées dans la fonction.

int square(int toto) {
    int toto;  // illégal depuis le C Ansi
}

Les chaines de caractère sont concaténées à la 6ème phase de traduction . On peut facilement construire des chaines de caractère multiligne.

int main()
{
    "aa"
    "bb"; // "aabb"
}

En K&R C on devait utiliser une anti barre oblique

int main()
{
    "aa\
bb"; // "aabb"
}

On peut rapidement creer des tableaux de caractères à partir d’une chaine littérale, le caractère nul terminal pouvcant être élidé si besoin

int main()
{
    char tab[4] = "toto"; // noter que le \0 terminal est simplement ignoré
}

C++ : Cette construction n’a pas été adoptée par le C++ qui le considère une tentative éronée d’initialiser un tableau de 4 caractères avec 5 valeurs.