Ich hatte das Gefühl, dass ich den Python-Code nach C ++ 98 portiert habe.

Auch wenn es in Python präzise geschrieben werden kann, ist es notwendig, eine große Menge an Vorlagencode in C ++ 98 zu schreiben. Als Referenz (?) Habe ich den C ++ - und Python-Code nebeneinander angeordnet.

Kurz gesagt: "Dynamisches Tippen mit Syntaxzucker ist wunderbar."

(Da es gerade geschrieben wird, wird es möglicherweise in Zukunft weitere Elemente geben.)

Teil 1 Statische / dynamische Eingabe

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 ++: Zusätzlich zu Typen sind Modifikatoren wie const, * und &, Vorlagen problematisch. (Obwohl die Eingabe / Ausgabe angegeben ist und die Syntaxprüfung beim Kompilieren hilfreich ist ...) Python: Dynamisch typisiert, keine Typdefinition erforderlich. Der Typ hat einen Wert, keine Variable.

Teil 2 Liste und Wörterbuch

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

def calculate(lines):
  result = [] // []Im Listenformat, {}Wörterbuch.
  for line in lines:
    value =Etwas tun(line)
    result.append(value)
  return result

C ++: In C ++ 98 gibt es keinen Syntaxzucker (C ++ 11 hat Syntaxzucker).

Python: Objekterstellung, Elementzugriff, Schleifen mit Syntaxzucker. Der obige Fall kann unter Verwendung der Listeneinschlussnotation genauer beschrieben werden.

def calculate(lines):
  result = [Etwas tun(line) for line in lines]
  return result

Teil 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 ++: Wenn Sie Werte gruppieren möchten, müssen Sie ein generisches Paar verwenden oder eine Struktur / Klasse wie Punkt oder Linie definieren. Dies ist auch ein Kompromiss bei der Syntaxprüfung.

Python: Taple ist praktisch, wenn Sie ein kleines Paar als Argument übergeben möchten. Übermäßiger Gebrauch verringert die Lesbarkeit.

Teil 4 Lambda-Typ

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

//Suchen Sie die y-Koordinate, die x entspricht, auf der geraden Linie.
// ※：y=1 oder x=Berücksichtigen Sie keine Zeilen wie 0.
double func(const Line& line, double x) {
   //Neigung bekommen
   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)

Lambda-Ausdrücke werden in Python bereitgestellt, sodass Sie problemlos kleine Dinge schreiben können. In C ++ verbessert das Schreiben einer Klasse die Wiederverwendbarkeit, aber der Schwellenwert für das Schreiben ist hoch.

Teil 5 Funktionsaufruf

Sie können Taples und Listen einfach in einzelne Argumente erweitern oder benannte Argumente erstellen.

Beispiel: Reduzieren Sie die Überlastung der C ++ - Funktion.

doule get_distance(const Point& pt1, const Point pt2) {
   return //Berechnungsergebnis
}

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) //Wenn die Linie ein Taple oder eine Sequenz ist, zeigt Punkt1 automatisch,Erweitern Sie auf Punkt2.