2- Syntaxes de base en C++

1- Types de base - Opérateurs

2- Sructures de controle

3- Les fonctions

4- Les tableaux

x=a+b;

x=		a
+	b	;

std::cout << "HelloWorld !\n";

Voir la documentation de votre compilateur pour savoir les tailles de stockage et donc les valeurs limites pour chaque type. Une autre solution est d'exécuter le code suivant : VoirTailleTypes.cpp.

Une variable entière peut être signée ou non (signed/unsigned). Sans autre indication, les variables sont signés en l'absence du mot clé unsigned. Les entiers signés sont soit négatifs, soit positifs alors que les entiers non signés sont toujours positifs. Soit par exemple une implémentation telle qu'un entier est codé sur 4 octets. Dans le cas d'un int signé, il est à valeurs dans [-32768:32767]. Dans le cas d'un int non signé, il est à valeurs dans [0:65535].

Une variable de type caractère est codée sur un octet, soit 8 bits. En tout il y a 2⁸=256 caractères numérotées de 0 à 255 qui sont les 256 caractères de la norme ASCII. Des caractères spéciaux sont disponibles :

Caractere	Signification
\a	Alerte sonore
\b	Retour en arrière
\f	Saut de page
\n	Nouvelle ligne
\r	Retour chariot
\t	tabulation
\v	Tabulation verticale
\'	guillemet simple
\"	guillemet double
\?	Point d'interrogation
\\	Barre oblique inverse
\000	Notation octale
\xhhh	Notation hexadécimale

TestsCaracteresSpeciaux.cpp

Initialisation et affectation de variables

int i=8;/*Declaration et affectation*/
int j;/*Declaration*/
j=7;/*Affectation*/
char c='a';/*Declaration et affectation*/
char d='\n';/*Décalaration et affectation, caractère de saut de ligne*/
char tabulation='\t';/*Décalaration et affectation, caractère de tabulation*/
int n1,n2,n3;/*Declaration multiple*/
double x1=0.1,x2=1002.5,x3=9;/*Decalaration et affectation multiple*/
long int h=89;/*Declaration d'un entier de type long*/
unsigned short x;/*Declaration d'un entier short non signé*/

NB1 : C++ est un langage typé : toutes les variables utilisées ont dues êtres préalablement déclarées.

NB 2 : Attention : en C++, la déclaration ne vaut pas affectation implicite. Dans le cas des langages comme java la délaration sans affectation d'une variable int a conduit à son initialisation à a. En C ou en C++, cela n'est pas vrai.

Opérateurs arithmétiques et transtypage

int y=5;
int n=3;
x=y/n;

double x=2.5;
short int u;
u=(short int)x;

Conditions logiques

bool b0=(5<6);
std::cout<<b0;/*Affiche 1 qui correspond à vrai*/
bool b1=(5==1 && 6>5);
std::cout<<"La valeur de b1 "<<(b1);/*Affiche 0 qui correspond à faux*/
bool b2=('\n'=='\n' || 5>6);
std::cout<<(b2);/*Affiche 1*/
bool b3=(7!=5.65 && (3>4 || 6>5));
std::cout<<"\n"<<(b3);/*Affiche vrai*/

z=(x>y) ? x : y;

Ecrire en sortie sur l'écran

int i=6;
std::cout<< "Valeur de i : "<<i<<"\n";

int i=6;
int j=9;
double x=77.76;
std::cout<<"La valeur de i est : "<<i<<" , la valeur de j est : "<<j<<", enfin, celle de x est : "<<x<<"\n";

std::cout << " x : " << x << std::endl;

Récupérer une valeur saisie par l'utilisateur

std::cin >> x;

#include

int main()
	{
    	double x;
	std::cout << "Rentrez une valeur entiere" << std::endl;
    	std::cin >> x;
    	std::cout << "La valeur que vous avez saisie " << x << std::endl;
	return 0;
	}

Déclaration de constante et énumération

const int PI=3.14;

enum categorie {CADRE, OS, COMPABLE, DRH, PRESIDENT};

categorie myCat=OS;

Libraire Standard

Génération de valeurs aléatoires

Les fonctions nécessaires à la génération aléatoire sont contenues dans la librairie <cstdlib>. La génération de nombres aléatoires implique d'abord d'initialiser la racine (seed) par l'instruction :

srand(time(0));

int test=rand()%7;

double x=rand()/(double)RAND_MAX;

Utilisation de fonctions

#include 

void testAffichage()
	{
	std::cout << "Ceci vient de testAffichage()\n";
	}

int main()
	{
	std::cout << "Ceci vient de main()\n\n";
	testAffichage();
	return 0;
	}

	

	for(instruction d'initialisation;instruction de poursuite / arrêt de la boucle;instruction à chaque tour de boucle)
	{
	/*Les instructions qui sont répétées dans la boucle*/
	}

int somme=0;	
	for(int i=0;i<5;i++)
	{
	somme=somme+i;
	std::cout<<i<<"\t"<<somme<<"\n";
	}

	while(Condition(s) Logique(s))
	{
	/*Les instructions qui sont répétées dans la boucle*/
	}

int somme=0,i=0;	
	while(i<5)
	{
	somme=somme+i;
	std::cout<<i<<"\t"<<(sommme)<<"\n";
	}

	if(Conditons 1)
	{
	/*Instructions sous les conditions 1*/
	}
	else if(conditions 2)
	{
	/*Instructions sous les conditions 2*/
	}
	else
	{
	/*Instructions si ni les conditions 1, ni les conditions 2 ne sont vérifiées*/
	}

	if(Conditions 1)
	{
	/*Instructions sous les conditions 1*/
	}

	if(Conditons 1)
	{
	/*Instructions sous les conditions 1*/
	}
	else if(conditions 2)
	{
	/*Instructions sous les conditions 2*/
	}
	else if(conditions 3)
	{
	/*Instructions sous les conditions 3*/
	}

	if(condition1)
	L'instruction qui dépend de la condition 1;

	for(i=0;i<100;i++)
	L'instruction unique de la boucle;

int maFonction();

int maFonction(int a,float x);

double calculAire(double longueur,double largeur);

 
#include <iostream>
#include <cmath>

int main
	{
	std::cout << "La valeur absolue de 0.5 : << std::abs(0.5) << "\n";
	std::cout << "La valeur absolue de -0.5 : << std::abs(-0.5) << "\n";
	std::cout << "Le carre de 2 : << std::sqrt(2) << "\n";
	return 0;
	}

#include <iostream>
#include <cmath>

using namespace std;

int main
	{
	cout << "La valeur absolue de 0.5 : << abs(0.5) << "\n";
	cout << "La valeur absolue de -0.5 : << abs(-0.5) << "\n";
	cout << "Le carre de 2 : << sqrt(2) << "\n";
	return 0;
	}

double calculAire(double longueur,double largeur)
	{
	return longueur*largeur;
	}

Passage de paramètres à une fonction

#include 
void myFunction();	//prototype

int x=5,y=7;	//variables globales

using namespace std;

int main()
	{
	cout << "x dans la fonction main : " << x << "\n";
	cout << "y dans la fonction main : " << y << "\n";
	myFunction();
	cout << "\nDe retour de myFunction. \n\n";
	cout << "x dans la fonction main : " << x << "\n";
	cout << "y dans la fonction main : " << y << "\n";
	}

void myFunction()
	{
	int y=10;
	cout << "\nx provenant de myFunction : " << x << "\n";
	cout << "y provenant de myFunction : " << y << "\n\n";
	}

x dans la fonction main : 5
y dans la fonction main : 7

x provenant de myFunction : 5
y provenant de myFunction : 10

De retour de myFunction

x dans la fonction main : 5
y dans la fonction main : 7

Renvoi de valeur

return 77.8;
return x;
return MyFunction();
return (x>y);

Surcharge de fonction / polymorphisme

int maFonction(int,int);
int maFonction(long,long);
int maFonction(long);

Une fonction de la librairie standard : system

Le tirage de valeurs aléatoires

Faire un include sur iostream pour avoir les fonctions de génération aléatoire. Pour initialiser le générateur aléatoire, une instruction à placer en début de main : srand(time(0));. Ensuite, on utilise la fonction rand() qui génère un nombre aléatoire entier entre [0;RAND_MAX].

double per[19];

per[7]=6.78;
double w=per[7]*0.112;