1. Introduction au C++

1.5. Améliorations du C++ par rapport au C

1.5.1. Le qualificateur const

Le langage C++ introduit le qualificateur const qui indique qu'une donnée ne sera pas modifiée. Situé au niveau d'un sous-programme const indique qu'aucune donnée ne sera modifiée à l'intérieur du sous-programme. le qualificateur const peut également servir à :

définir des constantes
spécifier qu'une méthode ne peut modifier des données membres

CODE
amelioration_const.cpp

// instead of #define N 5
const int N = 5;
 
int R;
 
class A {
    int a;
 
  public:
    // int is already const: const int f(...)
    const int f(const int n) const {
      N = 1; // forbidden !!
      n = 3; // forbidden (2nd const)           
      a = 2; // forbidden (3rd const)
 
      R = 5; // allowed
    }
};
 
 
 
 
 

En ce qui concerne les pointeurs constants, on peut les déclarer de plusieurs manières :

CODE
amelioration_const_ptr.cpp

#include <iostream>
#include <string.h>
using namespace std;
 
const char *ptr1 = "modifiable";
const char * const ptr2 = "non modifiable";
char ptr3[] = "a string";
 
int main() {
    ptr1 = "coucou";
    cout << "ptr1 = " << ptr1 << endl;  
    
    // 1. not possible !!!!
    // error: assignment of read-only variable ‘ptr2’
    ptr2 = "toto";
    // 2. error: invalid conversion from ‘const char*’ to ‘char*’ [-fpermissive]
    strcpy(ptr2, "toto");
    
    strcpy(ptr3, "toto");
    cout << "ptr3 = " << ptr3 << endl;
    
    // 3. will produce overflow and Segmentation fault
    strcpy(ptr3, "totototototototototototo");
    cout << "ptr3 = " << ptr3 << endl;
        
    return 0;
}
 

1.5.2. le qualificateur enum

Le mot clé enum permet de déclarer des énumérations ou un nouveau type (entier) associé à une liste de valeurs.

C++11 introduit les enum class que l'on qualifie d'énumération à portée (scoped) pour lesquelles il est nécessaire de spécifier le nom qui définit l'énumération :

CODE
amelioration_enum.cpp

#include <iostream>
#include <cstdlib>
using namespace std;
 
// unscoped enumeration
// zero = 0, un = 1, ...
enum { zero, un, deux, trois };
 
// unscoped enumeration
// mardi = 2, ....
enum Jour { lundi=1, mardi, mercredi, jeudi, vendredi, samedi, dimanche };
 
// Scoped enumeration
enum class Mois { Janvier = 1, Fevrier, Mars, Avril, Mai, 
    Juin, Juillet, Aout, 
    Septembre, Octobre, Novembre, Decembre };
 
 
int main() {
 
    // un_jour = 2, no scope
    Jour un_jour = mardi; 
    // can convert easily to integer if unscoped
    int m = un_jour;
    
    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 
    // because unscoped enum 'mardi' does not reference
    // the constant of Jour
    int mardi = -123; 
    // you have to write this:
    mardi = Jour::mardi; 
    
 
    cout << "un_jour = " << un_jour << endl;
    cout << "mardi = " << mardi << endl;
 
    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    // still possible to write this !
    int Janvier = -56;
    
    // need to cast a scoped constant
    cout << "Fevrier = " << static_cast<int>(Mois::Fevrier) << endl;
    
    return EXIT_SUCCESS;
}
 

un_jour = 2
mardi = 2
Fevrier = 2

Par défaut, les énumérations à portée sont de type int mais on peut modifier leur comportement :

enum Class Status: std::uint32_t;
enum Class Jour: std::uint8_t;

1.5.3. Espace de nom (namespace)

Pour des projets de grande envergure, des conflits de noms apparaissent pour certains noms de classes ou de variables. C'est par exemple le cas si on tente d'utiliser différentes librairies de calcul ensemble comme BLAS, GSL et MKL. Si on utilise le produit de matrices, le sous-programme cblas_dgemm existe sous BLAS et MKL. De même, les constantes comme CblasNoTrans est redéfnie dans chaque librairie.

Le C++ offre un moyen de remédier à ce problème en limitant la portée des symboles à une zone appelée espace de nommage ou namespace, appliqué à l'exemple précédent on aurait :

namespace cblas {
  enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113};
  void cblas_dgemm(...);
}

namespace mkl {
  typedef enum {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113} CBLAS_TRANSPOSE;
  void cblas_dgemm(...);
}

namespace gsl {
  typedef  enum CBLAS_TRANSPOSE   CBLAS_TRANSPOSE_t;
  int  gsl_blas_dgemm(...);
}

Pour accéder à une déclaration de l'espace de nommage on peut utiliser l'opérateur de résolution de portée :: ou alors utiliser l'instruction :

#include "mkl.h"
#include "cblas.h"
#include "gsl_cblas.h"

cblas::cblas_dgemm(cblas::CblasRowMajor, cblas::CblasNoTrans, ...);
mkl::cblas_dgemm(mkl::CblasRowMajor, mkl::CblasNoTrans, ...)
gsl::gsl_blas_dgemm(gsl::CblasRowMajor, gsl::CblasNoTrans, ...);

En particulier std est l'espace de nommage réservé à la STL (Standard Template Library).

Attention à ne pas utiliser un nom qui correspond à une fonction ou mot-clé du C. (ex: system)

Dans la partie header (.h) définir le namespace, puis dans la partie implementation (.cpp) l'utiliser :

CODE
namespace.h

#ifndef NAMESPACE_H
#define NAMESPACE_H
 
#include <iostream>
using namespace std;
 
namespace my_namespace {
 
    class A {
    protected:
        static int count;
        int data;
        
    public:
        A();
        A(int d);
        static int get_count();
        
        friend ostream& operator<<(ostream& out, A& obj);
    };
    
}
 
#endif
 
 

CODE
namespace.cpp

#include "c1_namespace.h"
 
using namespace my_namespace;
 
int A::count = 0;
 
A::A() {
    data = 0;
    ++count;
}
 
A::A(int d) {
    data = d;
    ++count;
}
 
int A::get_count() {
    return count;
}
 
// !!!!!!!!!!!!!!!!!
namespace my_namespace {
 
    ostream& operator<<(ostream& out, A& obj) {
        out << "A.data = " << obj.data;
        return out;
    }
 
}
 
int main() {    
    A a(3);
    
    cout << a << endl;
 
    cout << "count = " << A::get_count() << endl;
    return 0;
}
 

1.5.4. Entrées / sorties

La STL introduit des flux (stream) sur lesquels on peut réaliser des entrées/sorties. Par défaut on trouve les flux suivants :

cin : flux d'entrée standard (clavier)
cout : flux de sortie standard (écran)
cerr : flux d'erreur standard

On manipule ces flux comme en Java et non plus comme en C mais en utilisant des opérateurs spécifiques. Le symbole endl (enf of line) représente le caractère '\n'

// include the librairy for input/output
#include <iostream>
using namespace std;

int n;
cin >> n; // lecture d'un entier
cout << "la valeur de n est " << n << endl;

1.5.4.a flux de sortie

Des manipulateurs de flux sont définis qui permettent de formater l'affichage des données :

hex, oct, dec : affichage en hexadécimal, octal ou décimal
scientific : utilise la notation en virgule flottante
setprecition(int) fixe le nombre de chiffres significatifs
setw(int) donne la largeur minimale du champ
setfill(char) précise le caractère de remplissage

1.5.4.b flux d'entrée

Utilisation de la fonction istream& getline(istream& is, string& str, char delim) pour lire des chaines de caractères.

1.5.5. Typage

Afin de remédier aux déficiences du langage C concernant le typage, de nouveaux opérateurs sont introduits :

static_cast pour la conversion d'un type vers un autre type
const_cast pour supprimer ou ajouter le caractère constant d'une variable
dynamic_cast pour les hierarchies d'objets
reinterpret_cast pour conversion entre 2 types différents (int vers pointeur par exemple)

// tranform integer into double
int i=1;
double d = static_cast<double>(i);

int f(int& n) {
  return n+1;
}

int g(const int& n) {
  return f(const_cast<int>>(n));
}

1.5.6. Paramètres par défaut

La possibilité est offerte en C++ de donner une valeur par défaut uniquement aux paramètres les plus à droite dans la définition d'un sous-programme :

void fonction(int n, int m = 1) {
  cout << n << " " << m << endl;
}

f(1,5); // n = 1, m = 5
f(1); // equivalent to f(1,1) because m was not specified

Page de Jean-Michel Richer