Ziglang, un lenguaje de programación similar a C++ (2da parte)

Ya hemos hablado de Zig en otras ocasiones:

Para instalarlo puedes ver este enlace: https://ziglang.org/download/

Aunque hay otras formas de hacerlo: https://ziglang.org/learn/getting-started/

Conociendo Zig

Una vez instalado podemos abrir una terminal y verificar la versión instalada:

$ zig version

Salida:

0.16.0

También podemos obtener la ayuda:

$ zig --help

Salida:

Usage: zig [command] [options]

Commands:

  build            Build project from build.zig
  fetch            Copy a package into global cache and print its hash
  init             Initialize a Zig package in the current directory

  build-exe        Create executable from source or object files
  build-lib        Create library from source or object files
  build-obj        Create object from source or object files
  test             Perform unit testing
  test-obj         Create object for unit testing
  run              Create executable and run immediately

  ast-check        Look for simple compile errors in any set of files
  fmt              Reformat Zig source into canonical form
  reduce           Minimize a bug report
  translate-c      Convert C code to Zig code

  ar               Combine object files into static archive
  cc               Use Zig as a drop-in C compiler
  c++              Use Zig as a drop-in C++ compiler
  dlltool          Use Zig as a drop-in dlltool.exe
  lib              Use Zig as a drop-in lib.exe
  objcopy          Manipulate executables and relocatables
  objdump          Print information about executables and relocatables
  ranlib           Use Zig as a drop-in ranlib
  rc               Use Zig as a drop-in rc.exe

  env              Print lib path, std path, cache directory, and version
  help             Print this help and exit
  std              View standard library documentation in a browser
  libc             Display native libc paths file or validate one
  targets          List available compilation targets
  version          Print version number and exit
  zen              Print Zen of Zig and exit

General Options:

  -h, --help       Print command-specific usage

Crear y ejecutar un simple programa

Crearemos un programa en Zig.

holamundo.zig

const std = @import("std");

pub fn main() void {
    std.debug.print("Hola, mundo!\n", .{});
}

Lo compilaremos con el siguiente comando:

$ zig build-exe holamundo.zig

Esto compilará el programa y creará un ejecutable.

$.\holamundo.exe

Salida:

Hola, mundo!

Si solo quieres probarlo, puedes echar un vistazo en ésta página: https://codapi.org/zig/

Programando en Zig

Tipos de datos

Ya hemos hablado de los tipos de datos en Zig. En cualquier programa en el que usemos este lenguaje debemos definir el tipo de dato a usar. En comparación a C++, sus tipos de datos son muy similares.

Ejemplo 1. Programa que muestre algunas variables y tipos.

En C++:

variables.cpp

#include <iostream>
#include <string>

int main() {
    std::cout << "\t [   Variables en C++ ]\n";

    const int entero = 325;
    const double flotante = 12.65;
    const bool verdadero = true;
    const std::string cadena = "Murcielago";

    std::cout << "Número entero: " << entero << std::endl;
    std::cout << "Número flotante: " << flotante << std::endl;
    std::cout << "Cadena: " << cadena << std::endl;
    std::cout << "Booleano: " << std::boolalpha << verdadero << std::endl;

    return 0;
}

En Zig:

variables.zig

const std = @import("std");

pub fn main() void {
    std.debug.print("\t [   Variables en ZigLang ]\n", .{});
    const entero: i32 = 325;
    const flotante: f64 = 12.65;
    const verdadero: bool = true;
    const cadena = "Murcielago";

    std.debug.print("Número entero: {d}\n", .{entero});
    std.debug.print("Número flotante: {}\n", .{flotante});
    std.debug.print("Cadena: {s}\n", .{cadena});
    std.debug.print("Booleano: {}\n", .{verdadero});
}

Compilación:

$ zig build-exe variables.zig

Ejecución:

$ variables.exe

Salida:

         [   Variables en ZigLang ]
Número entero: 325
Número flotante: 12.65
Cadena: Murcielago
Booleano: true

Funciones y procedimientos

Los procedimientos no devolverán ningún valor (void) y las funciones si lo harán. Pueden o no tener parámetros definidos.

Ejemplo 1. Crear un programa que tenga dos funciones de suma y resta de números enteros. Haremos la versión en C++ y Zig.

En C++:

suma_resta.cpp

#include <iostream>

int suma(int x, int y) {
    return x + y;
}

int resta(int x, int y) {
    return x - y; 
}

int main() {
    const int a = 33;
    const int b = 56;

    std::cout << "Suma de " << a << " + " << b << " = " << suma(a, b) << std::endl;
    std::cout << "Resta de " << a << " - " << b << " = " << resta(a, b) << std::endl;

    return 0;
}

En Zig:

suma_resta.zig

const std = @import("std");

pub fn suma(x: i32, y: i32) i32 {
    return x + y;
}

pub fn resta(x: i32, y: i32) i32 {
    return x - y;
}

pub fn main() void {
    const a: i32 = 33;
    const b: i32 = 56;
    std.debug.print("Suma de {d} + {d} = {d}\n", .{ a, b, suma(a, b) });
    std.debug.print("Resta de {d} - {d} = {d}\n", .{ a, b, resta(a, b) });
}

Compilación:

$ zig build-exe suma_resta.zig

Ejecución:

$ suma_resta.exe

Salida:

Suma de 33 + 56 = 89
Resta de 33 - 56 = -23

A simple vista, Zig nos recuerda más a lenguajes como Go y Rust que a C++. Además su filosofía se enfoca en paradigma sin herencia, sin excepciones, sin macros; con compilaciones incrementales rápidas, aunque la primera compilación puede ser lenta.

Zig es más predecible y sencillo de aprender. Con un mejor control explícito de errores y memoria. Con compilaciones rápidas en proyectos pequeños/medianos. Ideal para subsistemas nuevos (asset pipelines, herramientas internas).

Eso es todo por el momento. Continuaremos con este tema en próximas entregas.

Enlaces:

https://ziglang.org/documentation/master/

Alquimista de código

Buscar este blog