C++ im Vergleich zu ZIG

1. Einleitung

Einleitung

Seit 20 Jahren begleitet mich C++ und stellt für mich “die beste Sprache” dar. Und der Grund dafür ist einfach:
C++ kann C Code ohne Zwischenschritte nutzen und produzieren.

Jede Zeile C Code ist gültiger C++ Code und jede mit
extern "C" eingeleitete Zeile in C++ produziert C Funktionen, die mit C++ Mitteln implementiert sind.

Eine bessere Integration gibt es nicht … zumindest gab es sie nicht bis ZIG auftauchte.

ZIG kann C Code ebenfalls direkt inkludieren und nutzen, während mit extern markierte Funktionen wieder von C Code angesprungen werden können.

Hello World

//C++
#include <cstdio>

int main()
{ // main program entry point
  printf("Hello %s\n", "World");
  return 0;
}

//ZIG
const std = @import("std");

pub fn main() u8 {
  // main program entry point
  std.debug.print("Hello {s}\n", .{ "World" });
  return 0;
}

• @import() lädt eigene Module oder Elemente der Standard Bibliothek.
• Der Inhalt eines importierten Moduls ist ein Typ (quasi ein struct).
• const mytupel = .{ value1, value2 } erzeugt ein Tupel mit den Typen der übergebenen Werte.

Funktionen und Parameter

 //C++
 #include <cstdio>
 
 static double add(int const a, float const b)
 { // local private function
   auto d = static_cast<double>(a);
   d += b;
   return d;
 }

void run_add()
{ // public function
  double const d = add(12, 34.0f);
  printf("%e\n", d);
}

 //ZIG
 const std = @import("std");
 
 fn add(a: i32, b: f32) f64 {
   // local private function
   var d = @as(f64, @floatFromInt(a));
   d += b;
   return d;
 }

pub fn run_add() void {
  // public function
  const d: f64 = add(12, 34.0);
  std.debug.print("{e}\n", .{ d });
}

• Variablen werden mit var x = ... deklariert, Konstanten mit const x = ...
• Der Typ wird automatisch von der Zuweisung abgeleitet, oder explizit angegeben const x: type = ...
• Explizite Casts finden mit @as(type, expression) statt.
• Funktionsparameter sind in ZIG automatisch const und können in der Funktion nicht verändert werden.

Optionale Werte

C++17 führt mit std::optional<T> die Möglichkeit ein, Variablen als “leer” oder befüllt zu unterscheiden. In ZIG sind “Optionals” Teil der Kernsprache und werden mit ? identifiziert.

 //C++
 #include <optional>
 
 static std::optional<int> add_opt(std::optional<int> const& a, int b)
 {
   if(a)
   {
     auto value = *a;
     return value + b;
  }
  else
  {
    return std::nullopt;
  }
}

void run_add_opt()
{
  auto value1 = add_opt(12, 34);
  printf("value1=%d\n", *value1);
  auto value2 = add_opt(std::nullopt, 34);
  if(!value2.has_value())
  {
    printf("value2 has no value\n");
  }
}

 //ZIG
 const std = @import("std");
 
 fn add_opt(a: ?i32, b: i32) ?i32 {
   if(a) |value| {
     return value + b;
   }
   else {
     return null;
  }
}

pub fn run_add_opt() void {
  const value1 = add_opt(12, 34);
  std.debug.print("value1={d}\n", .{ value1.? });
  const value2 = add_opt(null, 34);
  if(value2 == null) {
    std.debug.print("value2 has no value\n", .{ });
  }
}

Fortsetzung folgt