C/C++ [mots cléfs]

Langage C/C++

Pour ceux qui ont une maitrise parfaite sur le C/C++, si vous trouvez des éreurs...
Prévenez moi! ^^ ( On sait jamais. )

Bon, j' ai un petit conseil pour vous...
Ne vous découragez pas quand vous lirez le tutorial:
Il est grand, certe, mais c'est rien comparé aux cours majistraux de programmation.
Oh ça ouais! xD
Occupez vous juste de ce qui vous intérrèsse.
Les titres sont écrits en assez gros.

Partie I

Commentaires:

Façon 1:

/* commentaire */


Façon 2:


//commentaire sur tout le reste de la ligne





Bibliothèques, classes, fonctions:

Bibliothèques:

#include <iostream.h>
Inclus la bibliothèque iostream.h
<cstdlib>
Bibliothèque.
<windows.h>
Autre bibliothèque.


Classes:
Class xxx {
/*fonctions*/
};


Fonctions:
Fonction pour quitter un programme:
exit(0);

//La fonction getchar se trouve dans la librairie, <stdio.h>.
getchar(); // Renvoie un caractère provenant du flux d'entrée stdin

<stdlib.h>Les deux fonctions ci-dessous se trouvent dans la libraire stdlib.h
Pour allouer de la mémoire au système d' exploitation:
void* malloc(size_t nombreOctetsNecessaires);
exemple:
long* memoireAllouee = NULL; // On crée un pointeur sur long

memoireAllouee = malloc(sizeof(long)); /* La fonction malloc inscrit dans notre pointeur l'adresse qui a été reservee. */

Pour faire une allocation dynamique avec un tableau:

amis = malloc(nombreDAmis * sizeof(long));


Pour libérer la mémoire:
void free(void* pointeur);
exemple:

int main(int argc, char *argv[])
{
long* memoireAllouee = NULL;

memoireAllouee = malloc(sizeof(long));
if (memoireAllouee == NULL) // On vérifie si la mémoire a été allouée
{
exit(0); // Erreur : on arrête tout !
}

// On peut utiliser ici la mémoire

free(memoireAllouee); // On n'a plus besoin de la mémoire, on la libère

return 0;
}


type fonction(type_de_donnée_à_renvoyer, type_de_donnée_à_renvoyer, etc.. ){
/*manipulations*/
};
/*La fonction*/
fabs(variable); /* permet de renvoyer une valeur toujours positive ( une valeur toujours
absolue)*/

sqrt(nombre); /* cette fonction permet de calculer la racine carée d' un nombre.
double v = 0, n = 100;
v = sqrt(nombre); // resultat vaudra donc 10
*/

sin(); //O/H

cos(); //A/H

tan(); //O/A


asin(); // arc sinus

acos(); // arc cosinus

atan(); // arc tangente

exp(); //Cette fonction calcule l'exponentielle d'un nombre. Elle renvoie donc un double.

log(); /*Cette fonction calcule le logarithme népérien d'un nombre (que l'on note aussi "ln")*/

log10(); /*Cette fonction calcule le logarithme base 10 d'un nombre. */

/*Toutes les fonctions si-dessus sont dans la bibliothèque(directive de prépocesseur) <math.h>*/

#include <time.h>
/*pour se servir de la fonction rand*/

rand()//Permet de générer un nombre au hasard.

/* formule:
srand(time(NULL));
variable = (rand() % (M - m + 1)) + m;
/*M = max m = min*/

sizeof(){ // cette fonction permet de retourner les tailles des variables
}

pow(x, e); /*x la variable ou valeur et e l' exposant permet de calculer la puissance d' un nombre*/

ceil(flottant); //Permet d' arrondir au nombre suppérieur la variable flottant ou la valeur

floor(flottant); // inverse de la fonction ceil, arrondie au nombre inférieur

/*Les fonctions dans la bibliothèque <string.h>
Il y en a une 40e*/

/*Je rappele que chaque fonction doit être typée! Ca peut toujours servir que je fasse des rappels.*/

/*Les fonctions ci-dessous sont dans la librairie, <string.h>*/

size_t strlen(const char* chaine);
/*size_t est un type spécial qui signifie que la fonction renvoie un nombre correspondant à une taille. Ce n'est pas un type de base comme int, long ou char, c'est un type "inventé".
exemple:
char chaine[] = "Salut";
long longueurChaine = 0;
longueurChaine = strlen(chaine);
Donc longueurChaine devient égale à 5. ^^
*/

strcpy(nom_de_la_chaîne_destination, nom_de_la_chaîne source);
//ou encore:
strcpy(nom_de_la_chaîne_destination, "chaîne");
/* cette fonction permet de copier une chaîne entière de caractères dans une autre*/

strcmp(); /* cette fonction compare deux chaînes, même construction que la fonction strcpy. Cette fonction renvoye 0 si les deux chaînes sont les mêmes.*/

strcat(); /*Permet de concaténer deux chaînes.
exemple:
char* strcat(char* chaine1, const char* chaine2);*/

strchr(); /* Permet de rechercher un caractère dans une chaîne.
exemple:
char* strchr(const char* chaine, int LettreCherchée);
var1 = chaine cherchée var2 = c'est la lettre elle même qui faut mettre.*/

strpbrk(); /* Cherche le premier caractère d' une liste...
exemple:
chaine = strpbrk("Bonjour", "onr");

if (suiteChaine != NULL)
{
printf("Voici la fin de la chaine a partir du premier des caracteres trouvés : %s", chaine);
}
En clair,cette fonction coupe toutes les lettres avant la lettre cherchée.
" " = chaîne
' ' = lettre ( soit caractère)
*/

strstr(); // permet de rechercher une chaîne dans une autre...


system("CLS" ); // efface l' écran.

clrscr()//efface aussi l' écran.



Signes:


Signes pour les conditions:

!= différent
== rendre égal à
= égal
< inférieur à
> supérieur à
>= supérieur ou égal à
<= inférieur ou égal à
((condition)&&(condition)) "et"
((condition)||(condition)) "ou"
(!(condition)) le "!" veut dire: si la condition n' est pas vrai
(0 or 1) false or true, j' vous laisse deviner la traduction. ^^ faux ou vrai, la voilà!

Signes pour ajuster les variables ou autres..:

== rendre égal à
= égal
+= ajoute
-= soustrait
*= multiplis
/= divise
%= module

= égal
+ plus
- moins
* fois
/ divise
% modulo ( fait une division mais en gardant pour résultat le reste. )



Conditions:


1ere façon:

switch (variable){

case v:

break;
case b:

break;
défault:

break;
}


2eme façon:

if ((condition1)){

}
else {

}

/*Sur le else, on peut rajouter une nouvelle condition par la syntaxe suivante:*/
else if (condition){

}


3eme façon:

variableA = (variableB) ? Z : U;
/*variable = ( condition booléen) suivie de "?" Z = valeur1 ( à l' emplacement du if)
+ ":" qui sépare if du else et U = valeur2 ( à l' emplacement du else)*/



Boucles:

1ere façon:

while ((condition)signe(conditon2)){
//Tant que la condition est réalisée, la boucle ne s' arrête pas. signe = && or ||
}

do{

}while(condition);
Ce qui change avec do, c'est qu' on entre dans la boucle avant d' exécuter la première condition.


2eme façon:

for (compteur, condition, modif du compteur){

}


Variables et leur(s) type(s) de données:

Les variables ne doivent pas être des mots clés ou ayant des signes spécifiques ou encore des chiffres dans le nom de la variables.

Les pointeurs:

*nom_de_la_variable_pointeuse = &nom_de_la_variable_ciblée; /*"&" adrèsse mémoire d'une variable... Donc &nom_de_la_variable_ciblée donne son adrèsse mémoire.*/
Conseil: Initialiser les pointeurs à la valeur NULL.


Les pointeurs permettent d' avoir l' adrèsse mémoire d' une variable dans une autre variable.

Les types de données principales sont:

Dans les variables en C++, il y a:

Globale: Dans tous les fichiers:
- Les variables globales sont accéssibles dans toutes les fonctions...
Elles sont créées en général au dessous des librairies.

Dans un seul fichier:
On rajoute le mot clé "static" devant le type de données de la variable.
Mais attention ca n' a pas le même sens dans une fonction...
Voici le sens: Une variable déclarée dans une fonction avec le mot-clé static devant n'est pas supprimée à la fin de la fonction, elle conserve sa valeur au fur et à mesure de l'exécution du programme


Il se peut que vous ayez besoin de créer des fonctions qui ne seront accessibles que dans le fichier où se trouve la fonction.

Pour faire cela, rajoutez le mot-clé static devant la fonction : t = type
static type fonction(t p1, t p2){}


Locale: Elles sont crées dans les fonctions et accéssible que dans la fonction
où elle a été typée, elles sont supprimées lorsque la fonction est finie.

Type 1:

int // entier
float // flottant
char // caractère

Type 2: Tout ce qui est entre commentaire n' est pas obligé d' être mit.

unsigned + type1 = non signé
short + /*type2*/ + type1 = court
long + /*type2*/ + type1 = long
double + /*type2*/ + /*type1*/ = double
bool = booléen (affecte 1 si true sinon 0)
const = pour indiquer que c'est une constante. ( cette variable ne pourra jamais changer de valeur.)
struct = pour faire une structure ( struct homme {
int sexe;
int age;
char nom;
}
Toto.age = 12;
Toto.sexe = 1;
Toto.nom = Toto;

Ne pas oublier les ";" pour déclarer une action.

Je n' explique pas la place prise en mémoire par ces différents type.



En C++, on peut aussi créer nos propres types de données par:
typedef caractéristiques_du_type nom_du_type

typedef enum variable1 variable2;
enum variable2{
A, B, C
};
Permet de choisir une seule valeur en mémoire.


caractéristiques_du_type représente un type de donnée existant ( float, char, int, etc...)


Et le mot clé return permet de retourner (la ou les) variable/s.



Conversions:

Changer le type de donnée pour faire une conversion automatique.
Exemple un flottant x = 1,1513215 en entier
float x;
int x;
x aura pour valeur 1



Les tableaux (uni/bi/multi)dimensionnels:

Tableaux unidimensionnels:

type-de_donnée nom_du_tableau [x]

Tableaux bidimensionnels:

type-de_donnée nom_du_tableau [x] [y]

Tableaux multidimensionnels:

type-de_donnée nom_du_tableau [x] [y] [z]

x = nombre de colonnes ( axe abcisse x)
y = nombre de lignes ( axe ordonné y )
z = hauteur ( axe ???[hauteur] z )
Je mets "???" car je ne connais pas le "VRAI" nom de l' axe qui sert à faire des jeux en 3d.
On dit qu' il s' appelle z.
3d = 3 axes
2d = 2 axes



Les mots clés pour afficher des choses à l' écran(Sous console!):

Les fonctions printf(""); scanf(" ", variable) se trouvent dans la librairie <stdio.h>


printf ("message\n");
Pour afficher une variable c'est la formule suivante...
printf("vous avez %ld points sur votre permis et vous avez %ld d' argent\n", nom_de_la_variable_point, nom_la_variable_argent);


Et la fonction scanf permet d' écrire un nombre via le programme.( il me semble! ^^')
scanf("%lx", &variable);

x=d or f

%ld
Nombre entier (int)

%lf
Nombre décimal (float)

%p
Pour voir l' adrèsse mémoire d' une variable.
exemple:
printf("adrèsse mémoire de la variableA %p", %variableA);
Ca va afficher l' adrèsse mémoire de la variableA en base hexadécimale.

%c
Pour changer la valeur d' une variable en lettre à l' écran.

%s
Pour afficher une chaîne de caractères

Langage C/C++

Partie II

Signes à mettres dans les fonctions "printf"

\0 caractère de fin de chaîne
\" pour mettre des guillemets
\\ barre oblique inverse (antislash)
\a signal sonore(bip)
\b retour en arrière ( back space)
\f saut de page (pour l' imprimante)
\n retour à la ligne
\t tabulation
\v tabulation verticale ( pour l' imprimante)





Types de fichiers, Aide sur les librairies


* Les .h : appelés fichiers headers. Ces fichiers contiennent les prototypes des fonctions. Pour aider le pc à trouver les fonctions dans votre pc
Pour inclure des header, il faut faire le code suivant à coté des bibliothèque:
#include "fichier.h" // Et voilà!! ^^

* Les .c : les fichiers sources. Ces fichiers contiennent les fonctions elles-mêmes.

* Les chevrons < > pour inclure un fichier se trouvant dans le répertoire "include" de votre IDE
* Les guillemets " " pour inclure un fichier se trouvant dans le répertoire de votre projet (à côté des .c généralement )

Quand on inclut un header d'une librairie standard, il faut ajouter la librairie
<time.h>




Préprocesseur:
#include
Cette directive permet de inclure un fichier.h ou .c
En autre, un HEADER ou un SOURCE...
Pour une librairie c'est <librairie_choisie> pour un fihcier
autre qui ne fait pas parti de l' edi c'est "fichier.c ou h"

#define
Cette directive permet de définir une constante de préprocesseur. Cela permet d'associer une valeur à un mot.
exemple:
#define LARGEUR_FENETRE 800
#define HAUTEUR_FENETRE 600

Une macro:
#define SALUT() printf("Salut!!");


int main(int argc, char *argv[])
{
SALUT()

return 0;
}
Ce qui affichera à l' écran:
"Salut!!"
On peut rajouter des macros avec des "\" à la fin

#define MAJEUR(age) if (age >= 18) \
printf("Vous etes majeur\n");

int main(int argc, char *argv[])
{
MAJEUR(22)

return 0;
}

Langage préprocesseur:
Exemple:
#if condition
/* Code source à compiler si la condition est vraie */
#elif condition2
/* Sinon` si la condition 2 est vraie` compiler ce code source */
#endif

#ifdef pour dire "Si la constante est définie".
#ifndef pour dire "Si la constante n'est pas définie".


Constantes prédéfinies:
# __LINE__ : donne le numéro de la ligne actuelle
# __FILE__ : donne le nom du fichier actuel
# __DATE__ : donne la date de la compilation
# __TIME__ : donne l'heure de la compilation
#define NOMBRE_PIXELS (LARGEUR_FENETRE * HAUTEUR_FENETRE)

Langage C/C++

Partie III

Les fonctions pour ouvrir des fichiers:

FILE* fopen(const char* "nomDuFichier.ext", const char* "modeOuverture");

.ext = extension du fichier
modeOuverture =
* "r" : lecture seule. Vous pourrez lire le contenu du fichier, mais pas écrire dedans. Le fichier doit avoir été créé au préalable.
* "w" : écriture seule. Vous pourrez écrire dans le fichier, mais pas lire son contenu. Si le fichier n'existe pas, il sera créé.
* "a" : mode d'ajout. Vous écrirez dans le fichier, en partant de la fin du fichier. Vous rajouterez donc du texte à la fin du fichier. Si le fichier n'existe pas, il sera créé.
* "r+" : lecture et écriture. Vous pourrez lire et écrire dans le fichier. Le fichier doit avoir été créé au préalable.
* "w+" : lecture et écriture, avec suppression du contenu au préalable. Le fichier est donc d'abord vidé de son contenu, et vous écrivez et lisez ensuite dedans. Si le fichier n'existe pas, il sera créé.
* "a+" : ajout en lecture / écriture à la fin. Vous écrivez et lisez du texte à partir de la fin du fichier. Si le fichier n'existe pas, il sera créé.



Et encore, je n'ai pas tout mis là ! Il y a le double de ça en réalité ! Pour chaque mode qu'on a vu là, si vous rajoutez un "b" après le premier caractère ("rb", "wb", "ab", "rb+", "wb+", "ab+"), alors le fichier est ouvert en mode binaire. C'est un mode un peu particulier que nous ne verrons pas ici. En fait, le mode texte est fait pour stocker... du texte comme le nom l'indique (uniquement des caractères affichables), tandis que le mode binaire permet de stocker... des informations octet par octet (des nombres principalement). C'est sensiblement différent. Vous utiliseriez par exemple le mode binaire pour lire et écrire des fichiers Word octet par octet.
Le fonctionnement est quasiment le même de toute façon que ce que nous allons voir ici.

fichier = fopen("dossier/test.txt", "r+");
Pour ouvrir un autre fichier mais qui n' est pas dans le exe.

Méthode Windows:

fichier = fopen("C:\\Program Files\\Notepad++\\readme.txt", "r+");
Pour ouvrir un fichier qui est ailleurs sur votre pc!

Méthode avec Linux:

fichier = fopen("/Dossier/dossier2/texte.txt", "r+");

Et pour libérer la mémoire, il faudra utiliser la fonction suivante:
fclose(fichier);

Les fonctions pour écrire dans un fichier:


* fputc : écrit un caractère dans le fichier (UN SEUL caractère à la fois).
int fputc(int caractere, FILE* pointeurSurFichier);

* fputs : écrit une chaîne dans le fichier
char* fputs(const char* chaine, FILE* pointeurSurFichier);
* fprintf : écrit une chaîne "formatée" dans le fichier, fonctionnement quasi-identique à printf
fprintf(fichier, "Le Monsieur qui utilise le programme, il a %ld ans", age);

Pour lire quelque chose, il faut utiliser les fonctions ci-dessous:

* fgetc : lit un caractère
int fgetc(FILE* pointeurDeFichier);
* fgets : lit une chaîne
char* fgets(char* chaine, int nombreDeCaracteresALire, FILE* pointeurSurFichier);
* fscanf : lit une chaîne formatée

* ftell : indique à quelle position vous êtes actuellement dans le fichier
long ftell(FILE* pointeurSurFichier);
* fseek : positionne le curseur à un endroit précis
int fseek(FILE* pointeurSurFichier, long deplacement, int origine);
* rewind : remet le curseur au début du fichier (c'est équivalent à demander à la fonction fseek de positionner le curseur au début).
void rewind(FILE* pointeurSurFichier);





# Le nombre deplacement peut être un nombre positif (pour se déplacer en avant), nul (= 0) ou négatif (pour se déplacer en arrière).
# Quant au nombre origine, vous pouvez mettre comme valeur l'une des 3 constantes (généralement des defines) listées ci-dessous :

* SEEK_SET : indique le début du fichier.
fseek(fichier, 2, SEEK_SET);
* SEEK_CUR : indique la position actuelle du curseur.
fseek(fichier, -4, SEEK_CUR);
* SEEK_END : indique la fin du fichier.
fseek(fichier, 0, SEEK_END);




* rename : renomme un fichier
int rename(const char* ancienNom, const char* nouveauNom);
* remove : supprime un fichier
int remove(const char* fichierASupprimer);