Langage C

C - C++

Il est difficile de trouver ce qu'on veut sur les bases en C ou C++. Je liste ici aussi les fonctions les plus courantes.

Résumé C :

#include <stdio.h>
#include "mesfoncions.h"

#define PI 3.1415926535897932384626433832795 ...
struct point              structure point
{
  int x;
  int y;
};
typedef struct point      type
{
  int x;
  int y;
} monType;

int main(int argc, char * argv[])
{
   /déclarations/
   int nb;

   /corps/
   scanf("%d",&nb);
   printf("nb vaut: %d \n",nb);
   return 1;
}

Compilation sous Unix :

gcc -o nom_executable fichier1.c fichier2.c

Voici les types qui existent en C :

char : de 0 à 255 (ou de -127 à 127)
signed char : de -127 à 127
unsigned char : de 0 à 255
(signed) short : de -32767 à 32767
unsigned short : de 0 à 65535
(signed) int : de -32767 à 32767
unsigned int : de 0 à 65535
(signed) long : de -2147483647 à 2147483647
unsigned long : de 0 à 4294967295
(signed) long long : de -9223372036854775807 à 9223372036854775807
unsigned long long : de 0 à 18446744073709551615

Taille minimale des types:

char : 8 bits
short : 16 bits
int : 16 bits
long : 32 bits
long long : 64 bits

printf et scanf (stdio.h)
quelques formats: %c char
%d int
%f float%7.2f = 4 chiffres, le point et 2 chiffres (9999.99)
%s char *
%u unsigned int
%ld long int
%e float ou double écrit en puissance de 10

i++effectué après
++ieffectué en premier

opérateurs:
~ complément à 1inverse chaque bit
& ET logique bit par bit
| OU logique bit par bit
^ OU exclusif bit par bit
<<décalage des bits à gauche
>>décalage des bits à droite

&& ET logique
|| OU logique
exemple:

int nb = 9;
int Moitie;
Moitie = nb >> 1;

opérateur ternaire:
(condition ? valeur retournée si oui : valeur retournée si non); exemple:

if(A < B)
C=A;
else
C=B;

équivalent à

C = (A < B ? A : B);

tableaux:
int Tab[2][3]; <=> int Tab[3][2];    tableau à deux dimensions

pointeurs (aperçu) :
char Chaine[20];  Chaine est un pointeur sur le premier élément
int * pNb;  pointeur sur un entier
&pNb  valeur de l'entier pointé par pNb
structures de contrôle :

if(condition)
{
traitement
}
else
{
traitement
}

for(i=0; i<10; i++)
{
traitement 10 fois ici
}

int Sortie = 0;
int Nb;
while(Sortie == 0)
{
  printf("saisir une valeur:");
  scanf("%d",&Nb);
  if(Nb == 0)
    Sortie = 1;
}
Le code précédent n'est pas optimisé, c'est juste pour montrer la boucle while.

do
{
traitement
} while(condition);
On passe au moins une fois dans la boucle car la condition de continuité est vérifiée à la fin.

switch(variable)
{
  case 1:
  case 2:
     traitement 1
     break;
  case 3:
     traitement 2
     break;
  default:
     traitement par défaut
}

Quelles sont les fonctions sur les chaînes de caractères ?

dans string.h

char * STRCPY(char * but, const char * source); copie source vers but et retourne but.

char * strncpy(char * but, const char * source, int longueur_max); copie au maximum longueur_max caractères de source vers but.

char * STRCAT(char * but, const char * source); concatène source à but ("bon"+"jour"="bonjour")

char * strncat(char * but, const char * source, size_t longueur_max); concatène au maximum longueur_max caractères de source à but.

int STRCMP(const char * Ch1, const char * Ch2); compare Ch1 et Ch2

valeur de retour:
    négative si Ch1 < Ch2
    négative si Ch1 > Ch2
    0 si Ch1 = Ch2

int strncmp(const char * Ch1, const char * Ch2, size_t longueur_max); compare Ch1 et Ch2 sur au maximum longueur_max caractères

char * strchr(const char * Ch, char C); retourne un pointeur sur la première occurrence du caractère C dans Ch

char * strrchr(const char * Ch, char C); retourne un pointeur sur la dernière occurrence du caractère C dans Ch

char * STRSTR(const char * Ch1, const char * Ch2); retourne un pointeur sur la première occurrence de Ch2 dans Ch1

size_t STRLEN(const char * Ch); retourne la longueur de Ch

void * memcpy(void * but, const void * source, size_t lg); copie lg octets de source vers but (pas de recoupement possible entre source et but)

void * memmove(void * but, const void * source, size_t lg); copie lg octets de source vers but (recoupement possible entre source et but)

dans stdlib.h

int ATOI(const char * Ch); convertit Ch en entier

ATOF idem en double
ATOL idem en long

int itoa(int valeur, char * string, int base); convertit valeur en chaîne de caractères dans la base base
int rand(); retourne un entier aléatoire entre 0 et RAND_MAX

void * calloc(size_t nb_blocs, size_t taille); réserve nb_blocs consécutifs de chacun taille octets, initialise la zone à 0 et retourne le pointeur sur cette zone

void * malloc(size_t taille); réserve une zone de taille octets sans initialisation et retourne un pointeur sur cette zone

void realloc(void * adresse, size_t taille); modifie la taille de la zone allouée à l'adresse adresse

void free(void * adresse); libère la mémoire de la zone pointée par adresse

dans math.h

double cos(double x);
double sin(double x);
double tan(double x);
double acos(double x); arccos(x)
double asin(double x); arcsin(x)
double atan(double x); arctan(x)
double cosh(double x);
double sinh(double x);
double tanh(double x);
double EXP(double x); exponentielle(x)
double LOG(double x); logarithme népérien de x
double LOG10(double x); logarithme base 10 de x
double POW(double x, double y); x puissance y (x^y)
double SQRT(double x); racine carrée
double ceil(double x); arrondi x à l'entier supérieur
double floor(double x); arrondi x à l'entier inférieur
double fabs(double x); valeur absolue de x

dans ctype.h

int isalnum(char C); retourne 1 si C est une lettre ou un chiffre ou 0 sinon

int isalpha(char C); retourne 1 si C est une lettre ou 0 sinon

int isdigit(char C); retourne 1 si C est un chiffre ou 0 sinon

int islower(char C); retourne 1 si C est une lettre minuscule ou 0 sinon

int isspace(char C); retourne 1 si C est un séparateur (espace,fin de ligne,saut de page,tabulation) ou 0 sinon

int isupper(char C); retourne 1 si C est une lettre majuscule ou 0 sinon

Comment générer des nombres aléatoires ?

Il est souvent utile de pouvoir générer aléatoirement des entiers ou des réels :

#include <time.h>

...

/initialisation aléatoire/
srand(time(NULL));

nb = (int) (101 * ((float) rand() / RAND_MAX + 1)); nombre entier entre 0 et 100 (ce qui est appris en cours)

ou

nb = rand() % 101; idem

Comment lire et écrire dans un fichier ?

Ouverture et fermeture d'un fichier:

FILE * fich;
fich = fopen("c:\\fichier.txt",mode);
if(!fich) erreur;
fclose(fich);

mode peut prendre les valeurs suivantes:

"r" lecture
"w" création et écriture
"a" ouverture d'un fichier existant pour ajouter des données à la fin, sinon création
"r+" lecture et écriture d'un fichier qui doit exister
"w+" création et ouverture d'un fichier en lecture et écriture, remplacé si existant
"a+" ouverture d'un fichier en lecture et écriture pour ajouter des données à la fin, sinon création
" t" ou " b" si les fichiers textes(t) et binaires(b) sont différenciés, on peut ajouter la lettre après les valeures précédentes ("ab","a+b",...)

Fonctions pour manipuler les fichiers:

int fgetc(fich); lit un caractère, retourne l'entier correspondant
int fputc(char caractere, fich); écrit caractere, retourne l'entier correspondant
EOF retourné si fin de fichier

char * fgets(char * Ch, int longueur, fich); lit au maximum (n-1) caractères, placés dans Ch;
    "\0" est écrit à la fin.
int fputs(const char * Ch, fich); écrit Ch et retourne le nombre de caractères écrits.

fprintf(fich,"%d",Nb); comme printf, on précise le fichier.
fscanf(fich,"%s",Ch); comme scanf, on précise le fichier.

écriture de structures:
struct Personne
{
  char Nom[30];
  char Prenom[30];
} unePers;

scanf("%s",unePers.Nom);
scanf("%s",unePers.Prenom);
fich = fopen("c:\\fichier.txt","w");
fwrite(&unePers, sizeof(struct Personne), 1, fich); écriture d'un enregistrement
fread(&unePers, sizeof(struct Personne), 1, fich); lecture d'un enregistrement
fclose(fich);

Positionnement dans un fichier:

fseek(fich, déplacement en octets, mode);
    avec mode=0 : par rapport au début
    avec mode=1 : par rapport à la position courante
    avec mode=2 : par rapport à la fin

rewind(fich); on revient au début du fichier

int ftell(fich); retourne la position courante en octets par rapport au début

C - C++

gcc -o nom_executable fichier1.c fichier2.c

int nb = 9; int Moitie; Moitie = nb >> 1;

if(A < B) C=A;else C=B; équivalent à C = (A < B ? A : B);

if(condition) { traitement } else { traitement }

for(i=0; i<10; i++) { traitement 10 fois ici }

int Sortie = 0; int Nb; while(Sortie == 0) { printf("saisir une valeur:"); scanf("%d",&Nb); if(Nb == 0) Sortie = 1; }Le code précédent n'est pas optimisé, c'est juste pour montrer la boucle while.

do { traitement } while(condition); On passe au moins une fois dans la boucle car la condition de continuité est vérifiée à la fin.

switch(variable) { case 1: case 2: traitement 1 break; case 3: traitement 2 break; default: traitement par défaut }

#include <time.h> ... /*initialisation aléatoire*/ srand(time(NULL)); nb = (int) (101 * ((float) rand() / RAND_MAX + 1)); nombre entier entre 0 et 100 (ce qui est appris en cours) ou nb = rand() % 101; idem

FILE * fich; fich = fopen("c:\\fichier.txt",mode); if(!fich) erreur; fclose(fich);

fseek(fich, déplacement en octets, mode); avec mode=0 : par rapport au début avec mode=1 : par rapport à la position courante avec mode=2 : par rapport à la fin rewind(fich); on revient au début du fichier int ftell(fich); retourne la position courante en octets par rapport au début