À propos de ce qui est commun à C et C++

Bien que les langages C et C++ soient plus distincts que les gens ne le croient, il reste que ce sont tout de même des langages qui partagent un historique et qui ont quelques points en commun, sur le plan syntaxique comme sur le plan conceptuel.

Contrairement à ce que plusieurs pensent, C n'est pas un sous-ensemble de C++, et il existe des programmes C qui ne sont pas acceptés par un compilateur C++, le tout en pleine conformité avec les standards. En retour, les intersections entre les deux langages sont telles que plusieurs bibliothèques C sont utilisables directement en C++, et que des mécanismes sont en place pour faciliter les interactions entre programmes rédigés dans ces deux langages.

Dans un souci de réduire la redondance, voici quelques liens touchant ces deux langages à la fois (bien que souvent plus orientés autour de C++ que de C). Je les ai logés dans cette section plutôt que dans celle portant sur C++ par choix esthétique, sans plus.

Pour en savoir plus sur le préprocesseur, voir : preprocesseur.html

Généralités

Relations entre C et C++

Structures de contrôle

Quelques liens portant sur les structures de contrôle communes entre autres à ces deux langages.

Alternatives

Répétitives

Sélectives

Indirections

Les modalités d'indirection possibles en C se limitent aux pointeurs, incluant pointeurs sur des pointeurs (sur des pointeurs sur...) et pointeurs de fonctions. Celles de C++ incluent aussi les références et les pointeurs intelligents.

Pointeurs

Pointeurs de fonctions

Lors d'une conversation sur Slack, en 2017, quelqu'un a fait remarquer que, du fait que le nom d'une fonction est en fait son adresse, étant donné deux fonctions de même signature comme sinus() et cosinus() ci-dessous, l'appel suivant est légal :

#include <cmath>
#include <iostream>
#include <locale>
using namespace std;
//
// définir des fonctions sinus et cosinus, car std::sin et std::cos ont toutes deux plusieurs signatures
//
double sinus(double x) {
   return sin(x);
}
double cosinus(double x) {
   return cos(x);
}
enum class choix { Sinus, Cosinus };
class erreur_lecture {};
choix choisir_fonction() {
   const auto loc = locale{""};
   cout << "[s]inus ou [c]osinus? ";
   char c;
   while (cin >> c && (c = tolower(c,loc), c != 's' && c != 'c')) {
      cout << "[s]inus ou [c]osinus? ";
   }
   return c == 's'? choix::Sinus : c == 'c'? choix::Cosinus : throw erreur_lecture{};
}
int main() try {
   using namespace std;
   if (double x; cin >> x) { // C++17
      cout << (choisir_fonction() == choix::Sinus? sinus : cosinus)(x) << endl; // <-- ICI
   }
} catch (erreur_lecture&) {
   cerr << "Erreur de lecture" << endl;
}

Avant de critiquer C ou C++, sachez que ce type de manoeuvre est idiomatique de langages tels que Python, ce qui a d'ailleurs fait surgir la discussion sur C++ ce jour-là.

Entiers

Les types entiers et leur saine manipulation, bien qu'au coeur de la programmation, sont des objets de programmation périlleux en C et en C++ dû aux règles de débordement, aux cas limites et aux risques de comportement indéfini.

Tailles et distances

En C comme en C++, certains types jouent un rôle particulier dans la définition des tailles et des distances : le type std::size_t est un type entier non-signé qui sert à représenter les tailles des objets (c'est le type du nombre d'éléments des tableaux, et c'est le type retourné par l'opérateur sizeof), alors que le type std::ptrdiff_t est un type entier signé qui sert à représenter les distances (c'est le type de la différence entre deux pointeurs).