J'ai senti que j'avais porté le code Python en C ++ 98.

Même s'il peut être écrit de manière concise en Python, il est nécessaire d'écrire une énorme quantité de code de modèle en C ++ 98. Pour référence, j'ai arrangé le code de (?) C ++ et Python côte à côte.

En un mot, "le typage dynamique avec du sucre de syntaxe est merveilleux."

(Parce qu'il est sur le point d'être écrit, il peut y avoir plus d'articles à l'avenir)

Partie 1 Typage statique / dynamique

Point get_distance(const Point& point1, const Point& point2) {
  return sqrt( pow(point1.x - point2.x, 2) + pow(point1.y - point2.y, 2);
}

def get_distance(point1, point2):
  pt1_x, pt1_y = point1
  pt2_x, pt2_y = point2
  return math.sqrt((pt1_x - pt2_x) ** 2, (pt1_y - pt2_y) ** 2)

C ++: En plus des types, les modificateurs tels que const, * et &, les modèles sont gênants. (Bien que l'entrée / sortie soit spécifiée et que la vérification de la syntaxe au moment de la compilation soit utile ...) Python: typé dynamiquement, aucune définition de type requise. Le type a une valeur, pas une variable.

Liste et dictionnaire de la partie 2

vector<double> calculate(const vector<Line>& lines) {
  vector<double> result;
  vector<Line>::const_iterator ite = lines.begin();
  while( ite != lines.end() ) {
    double value =Faire quelque chose(*ite);
    result.push_back(value);
    ++ite;
  }
  return result;
}

def calculate(lines):
  result = [] // []Au format liste, {}dictionnaire.
  for line in lines:
    value =Faire quelque chose(line)
    result.append(value)
  return result

C ++: Dans C ++ 98, il n'y a pas de sucre de syntaxe (C ++ 11 a un sucre de syntaxe).

python: création d'objets, accès aux éléments, boucles avec sucre de syntaxe. Le cas ci-dessus peut être décrit de manière plus concise en utilisant la notation d'inclusion de liste.

def calculate(lines):
  result = [Faire quelque chose(line) for line in lines]
  return result

Partie 3 Taple

void foo() {
  Point pt1(0,1);
  Point pt2(0,5);
  Line line(pt1, pt2);

  double score;
  double distance;
  calculate(line, &score, &distance); 
  ...
}

void calculate(const Line& line, double* out_score, double* out_distance) {
  *out_distance = get_distance(line.point1, line.point2);
  *out_score = get_score(line);
}

double get_distance(const Point& pt1, const Point& pt2) {...}

def foo():
  pt1 = (0,1)
  pt2 = (0,5)
  line = (pt1, pt2)
  distance, score = caclculate(line)
  ...

def calculate(line):
  distance = get_distance(*line)
  score = get_score(line)
  return distance, score

def get_distance(pt1, pt2):
  ...

C ++: Si vous souhaitez regrouper des valeurs, vous devez utiliser une paire générique ou définir une structure / classe comme Point ou Line. C'est également un compromis avec la vérification de la syntaxe.

Python: Taple est pratique lorsque vous souhaitez passer une petite paire en argument. Une utilisation excessive réduira la lisibilité.

Partie 4 Type Lambda

void foo(const Line& line, double x) {
  double y1 = func(line, x);
  double y2 = func(line, x+1);
}

//Trouvez la coordonnée y correspondant à x sur la droite.
// ※：y=1 ou x=Ne considérez pas les lignes telles que 0.
double func(const Line& line, double x) {
   //Obtenez l'inclinaison
   double slope = get_slope(line.point1, line.point2);
   double const_value = get_const_value(line.point1, slope);
   double y = x * slope + c;
   return y;
}

def foo(line, x):
  func = get_func(line)
  y1 = func(x)
  y2 = func(x + 1)

def get_func(line):
  slope = get_slope(*line)
  const_value = get_const_value(line[0], slope)
  return (lamda x: x * slope + c)

Les expressions Lambda sont fournies en python, vous pouvez donc facilement écrire de petites choses. En C ++, l'écriture d'une classe améliore la réutilisabilité, mais le seuil d'écriture est élevé.

Partie 5 Appel de fonction

Vous pouvez facilement développer des taples et des listes en arguments individuels, ou vous pouvez créer des arguments nommés.

Exemple: réduire la surcharge de la fonction C ++.

doule get_distance(const Point& pt1, const Point pt2) {
   return //Résultat du calcul
}

double get_distance(const Line& line) {
  return get_distance(line.point1, line.point2);
}

def get_distance(point1, point2):
  return ...

def foo(line):
  get_distance(*line) //Si la ligne est un taple ou une séquence, point1 automatiquement,Développer au point2.