#include <stdio.h>

main()
{
  printf("Hello!\n");
}

blink LIB:c.o, hello.o  TO hello  LIB LIB:lc.lib, LIB:amiga.lib
        [A]      [B]       [C]    [D]     [E]          [F]

lc -L hello.c

lc -Lm 

lc -Lm ExempleX.c

#include "mydefinitions.h"

#include <intuition/intuition.h>

#define MAX_WIDTH 150
#define AUTHOR "Anders Bjerin"

#define SQUARE(x) x*x

nr = SQUARE(4);

nr = 4*4;

nr = SQUARE(4+1);

nr = 4+1*4+1

#define SQUARE(x) (x)*(x)
nr = SQUARE(4+1);

nr = (4+1)*(4+1);

nr = 16 / SQUARE(2);

nr = 16 / (2)*(2);

#define SQUARE(x) ((x)*(x))
nr = 16 / SQUARE(2);

nr = 16 / ((2)*(2)); /* OK */

#define BIG 1

#ifdef BIG
  #define HEIGHT 100  /* Si BIG est défini, HEIGHT et WIDTH */
  #define WIDTH  300  /* sont définis à 100 et 300.         */
#else
  #define HEIGHT  50  /* Si BIG n'est pas défini, HEIGHT et */
  #define WIDTH   25  /* WIDTH sont définis à 50 et 25.     */
#endif

#ifndef MY_DEFINITIONS      /* Si MY_DEFINITIONS n'est pas défini */
  #include "mydefinitions"  /* nous incluons "mydefinitions".     */
#endif

#define HEIGHT 200  /* HEIGHT est défini à 200.            */
#define HEIGHT 350  /* HEIGHT est redéfini à 350.          */
#undef HEIGHT       /* HEIGHT la dernière définition est   */
                    /* annulée et est redéfinie à 200      */
                    /* comme précédemment.                 */
#undef HEIGHT       /* HEIGHT n'est plus défini.           */

#include <stdio.h>

void main();             /* Ne retourne rien.                         */
int lit_rayon();         /* Retourne une valeur entière.              */
float calcule_aire();    /* Retourne une valeur en virgule flottante. */
void affiche_aire();     /* Ne retourne rien.                         */

void main()
{
  int rayon;
  float aire;

  rayon = lit_rayon();
  aire = calcule_aire( rayon );
  affiche_aire( aire );
}

int lit_rayon()
{
  int r;

  printf( "Entrez le rayon: " );
  scanf( "%d", &r );

  return( r );
}

float calcule_aire( r )
int r;
{
  float a;

  a = 3.14 * r * r;

  return( a );
}

void affiche_aire( a )
float a;
{
  printf( "L'aire est %f de unités carrées.\n", a );
}

#include <stdio.h>

main()
{
  lit_nombre();
}

lit_nombre()
{
  auto int nombre; /* <== Le voilà !             */
                   /* Le mot-clef "auto" est facultatif. */

  printf( "Entrez un nombre (0: Quitter) =>" );
  scanf( "%d", &nombre );
  if( nombre )
    lit_nombre();
  else
    printf( "%d\n", nombre );
}

#include <stdio.h>

void main();
void affiche_nombre();

void main()
{
  affiche_nombre( 3.142 );
}

void affiche_nombre( nombre )
float nombre;                /* <== Le voila! */
{
  printf( "Le nombre est %f!\n", nombre );
}

int nombre;        /* Stocké dans le segment BSS.  */
int largeur = 12;  /* Stocké dans le segment DATA. */

#include <stdio.h>

void main();

char nom = "Anders Bjerin";  /* Déclare cette variable comme une */
                             /* variable Global (DATA)           */
void main()
{
  affiche_nom();
}

#include <stdio.h>

void affiche_nom();

extern char nom;   /* Indique au compilateur que cette variable existe */
                   /* déjà mais est déclarée dans un autre module.    */
void affiche_nom()
{
  nom[ 3 ] = 'e';
  printf("Programmeur: %s\n", nom );
}

blink LIB:c.o, ModuleA.o, ModuleB.o TO program
LIB LIB:lc.lib, LIB:amiga.lib

static nombres[ 20 ];

#include <stdio.h>

void main();
void compteur();

void main()
{
  int boucle;

  for( boucle = 0; boucle < 20; boucle++ )
    compteur();
}

void compteur()
{
  static nombre = 1; /* Nous déclarons et initialisons une variable  */
                     /* Internal Static. Comme le nombre est une     */
                     /* variable Static elle ne sera initialisée que */
                     /* la première fois que nous appellerons la     */
                     /* fonction (DATA)                             */

  nombre++;

  printf("nombre: %d\n", nombre );
}

#include <stdio.h>

void main();

void main()
{
  register int boucle; /* <== La voilà ! */

  for( boucle = 0; boucle < 10000; boucle++)
    ;
}

int a;  /* "a" est une variable Integer.            */
int *b  /* "b" est un pointeur de variable Integer. */

b = &a; /* "b" contiendra l'adresse de la variable "a". */

struct personne
{
  int age;
  float taille, poids;
}

struct personne anders;

struct personne *programmeur;

anders.age = 20;
anders.taille = 1.92;
anders.poids = 74.5;

programmeur = &anders;

if( programmeur -> age == 20 )
  /* Le programmeur à 20 ans. */

programmeur -> poids -= 5; /* Le programmeur est au régime. */

WORD nombre;
LONG data;

data = (LONG) nombre;

struct personne anders;
CPTR programmeur;

programmeur = &anders;

Exemple.c 27 Warning 30: pointers do not point to same type of object

programmeur = (CPTR) &anders;

struct IntuitionBase *IntuitionBase;

main()
{
  /* Ouvre la bibliothèque Intuition (n'importe quelle version): */
  IntuitionBase = (struct IntuitionBase *)
    OpenLibrary( "intuition.library", 0 );

  if( IntuitionBase == NULL )
    exit(); /* Impossible d'ouvrir la bibliothèque Intuition! */

  ... ...

  /* Ferme la bibliothèque Intuition: */
  CloseLibrary( IntuitionBase );
}

struct GfxBase *GfxBase;

main()
{
  /* Ouvre la bibliothèque Graphics (n'importe quelle version): */
  GfxBase = (struct GfxBase *)
    OpenLibrary( "graphics.library", 0 );

  if( GfxBase == NULL )
    exit(); /* Impossible d'ouvrir la bibliothèque Graphics! */

  ... ...

  /* Ferme la bibliothèque Graphics: */
  CloseLibrary( GfxBase );
}