Déclaration des variables

 On peut déclarer des variables en tout endroit dans une bloc et non plus uniquement avant la première instruction du bloc.
{ int i; // déclaration de variables i = 2; // instruction int j; // autre déclaration de variable j = i; … for( int k = 0; k < 5; k++ ) { … } // valeur de k ici ? (dépend des compilateurs !) }

Fonction inline
 Fonction expansée (développée) à chaque appel
inline int carre(int x) { return x*x; }
int j = carre( 2 ); // j vaut 4
Ressemble à une macro C mais faire très attention dans la macro (effet de bord) !
C C ++ #define ABS(x) (x)>0 ? (x) : (-x)
int i, k = -1;
i = ABS( k ) ; // i vaut 1;
inline int abs( int x ) { return x>0 ? x : -x ;}
int i, k = -1;
I = abs( k ) ; // i vaut 1;
En C on utilise des macros expansés par le préprocesseur. Inconvénient : parfois difficile à écrire, pas de contrôle de type, mise au point difficile.

Paramètres optionnels avec valeur par défaut
void f ( float, int = 2, char * =  » « ) ; int g ( int *ptr = null , char ); // illégal
f ( 1.23, 10,  » bonjour « ); // appel classique f ( 1.23, 10 ); // => f ( 1.23, 10,  » « ); f ( 1.23 ); // => f ( 1.23, 2,  » « ); f ( ) // illégal f ( 1.23, ,  » bonjour « ); // => illégal f ( 1.23,  » bonjour  » ); // => illégal
 La définition des valeurs par défaut peut se faire soit dans le prototype de la fonction, soit dans l’entête de sa définition, mais pas dans les 2 à la fois. Mettre de préférence dans le prototype.  Les valeurs par défaut sont placées à partir de la fin de la liste des paramètres.

Surcharge des noms de fonctions
Surcharge ou encore surdéfinition : plusieurs fonctions ont le même nom.
Les fonctions doivent être différentiables par leur signature (la nature et le nombre de leurs paramètres )
int max(int, int ); int max( const int * list );
// mais erreur car même signature et valeur retournée différente char * cherche( char *); int cherche( char * );

Opérateurs (Objets) de sortie et d’entrée: << et >>

Ces opérateurs sont en réalité des opérateurs relevant des possibilités OBJET du langage. Ils sont introduits ici pour pouvoir les utiliser tout de suite sans attendre tous les développements nécessaires (et longs) à leur explication.
#include <stdio.h> #include <conio.h> #include <iostream.h> // pour pouvoir utiliser les flots cin et cout
int main() { int n; float x;
// méthode traditionnelle avec printf et scanf printf( « \n\nentrez un entier et un flotant : « ); scanf( « %d %f », &n, &x ); printf(  » le produit de %5d par %10.2f est : %10.2f\n », n, x, n * x );
// méthode C++ avec les flots cin et cout cout << « \n\nentrez un entier et un flotant :  » ; cin >> n >> x ; cout <<  » le produit de  » << n <<  » par  » << x <<  » est  » << n * x ;
return 0; }