(Translated by https://www.hiragana.jp/)
Zig - Wikibooks コンテンツにスキップ

Zig

リンクを追加ついか
出典しゅってん: フリー教科書きょうかしょ『ウィキブックス（Wikibooks）』
メインページ > 工学こうがく > 情報じょうほう技術ぎじゅつ > プログラミング > Zig

本書ほんしょは、プログラミング言語げんごZigのチュートリアルです。 Zigは、堅牢けんろうで最適さいてきかつ再さい利用りよう可能かのうなソフトウェアを維持いじするための汎用はんようシステムプログラミング言語げんごおよびツールチェインです[1]。 Zigは、アンドリュー・ケリー( Andrew Kelley )によって設計せっけいされ、静的せいてきで強つよい型付かたつけで型かた推論すいろんとジェネリックプログラミングをサポートします。

概要がいよう

[編集へんしゅう]

Zigは、2016年ねん2月がつに発表はっぴょうされた比較的ひかくてき若わかいプログラミング言語げんごで[2]、2024年ねん4月がつ23日にち現在げんざいの最新さいしんバージョンは 0.12.0 であり、pre-release と位置いちづけられています[3]。このため Hello world ですら、バージョン間あいだで互換ごかん性せいがなくなることもあり、今後こんごもリリースバージョンまでは言語げんご仕様しようやライブラリーおよびツールチェインの仕様しようが変更へんこうされる可能かのう性せいがあります。

クイックツアー

[編集へんしゅう]

Zigはメモリ安全あんぜん性せい、高速こうそくなビルド、そして明快めいかいな言語げんご設計せっけいを特長とくちょうとする新あたらしいプログラミング言語げんごです。

以下いかのZigのクイックツアーでは、基本きほん的てきな概念がいねんとコード例れいを紹介しょうかいします。

基本きほん構文こうぶん
Zigプログラムはmain関数かんすうから始はじまります。ここでは、stdout.writeAll()関数かんすうを使つかって標準ひょうじゅん出力しゅつりょくに文字もじ列れつを出力しゅつりょくしています。
hello.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    try stdout.writeAll("Hello, World!\n");  
}
実行じっこう結果けっか
Hello, world!
データ型がた
Zigには整数せいすう型がた、浮動ふどう小数点しょうすうてん型がた、真偽しんぎ値ちなどの基本きほん的てきなデータ型がたがあります。
types.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const age: i32 = 25;
    const salary: f64 = 50000.50;
    const isZigFun: bool = true;
    const message: []const u8 = "Hello, Zig!";
    const intOrNull: ?i16 = 42;
    const nullOrInt: ?i16 = null;
    const intOrError: anyerror!i16 = 178;
    const errorOrInt: anyerror!i16 = error.BadValue;
    
    try stdout.print("age = {}({})\n", .{age, @TypeOf(age)});
    try stdout.print("salary = {}({})\n", .{salary, @TypeOf(salary)});
    try stdout.print("isZigFun = {}({})\n", .{isZigFun, @TypeOf(isZigFun)});
    try stdout.print("message = {s}({})\n", .{message, @TypeOf(message)});
    try stdout.print("intOrNull = {?}({})\n", .{intOrNull, @TypeOf(intOrNull)});
    try stdout.print("nullOrInt = {?}({})\n", .{nullOrInt, @TypeOf(nullOrInt)});
    try stdout.print("intOrError = {!}({})\n", .{intOrError, @TypeOf(intOrError)});
    try stdout.print("errorOrInt = {!}({})\n", .{errorOrInt, @TypeOf(errorOrInt)}); 
}
実行じっこう結果けっか
age = 25(i32)
salary = 5.00005e+04(f64)
isZigFun = true(bool)
message = Hello, Zig!([]const u8)
intOrNull = 42(?i16)
nullOrInt = null(?i16)
intOrError = 178(anyerror!i16)
errorOrInt = error.BadValue(anyerror!i16)
制御せいぎょ構造こうぞう
if、else if、else文ぶんを使つかって条件じょうけん分岐ぶんきができます。whileループやforループを使つかって繰返くりかえし処理しょりができます。
flow-control
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const zero: f16 = 0.0;
    const num = zero/zero;
    if (num > 0.0) {
        try stdout.writeAll("Positive\n");
    } else if (num < 0.0) {
        try stdout.writeAll("Negative\n");
    } else if (num == 0.0) {
        try stdout.writeAll("Zero\n");
    } else {
        try stdout.print("num = {}\n", .{num});
    }
    
    var a: ?u16 = 42;
    if (a) |*value| {
        try stdout.print("value.* = {}({})\n", .{value.*, @TypeOf(value.*)});
        value.* = 123;
    } else {
        unreachable;
    }
    if (a) |n| {
        try stdout.print("n = {}({})\n", .{n, @TypeOf(n)});
    } else {
        unreachable;
    }
    a = null;
    if (a) |_| {
        unreachable;
    } else {
        try stdout.print("a = {?}({})\n", .{a, @TypeOf(a)});
    }
    
    var b: anyerror!u32 = error.BadValue;
    try stdout.print("b = {any}({})\n", .{b, @TypeOf(b)});
    if (b) |_| {
        unreachable;
    } else |err| {
        try stdout.print("err = {?}({})\n", .{err, @TypeOf(err)});
    }
    b = 4423;
    try stdout.print("b = {any}({})\n", .{b, @TypeOf(b)});
    if (b) |n| {
        try stdout.print("n = {}({})\n", .{n, @TypeOf(n)});
    } else |_| {
        unreachable;
    }
    
    var x: i32 = 0;
    while (x < 4) : (x += 1) {
        try stdout.print("While: Iteration {}\n", .{x});
    }
    for (0..4) |i| {
        try stdout.print("For: Iteration {}\n", .{i});
    }
}
実行じっこう結果けっか
num = -nan
value.* = 42(u16)
n = 123(u16)
a = null(?u16)
b = error.BadValue(anyerror!u32)
err = error.BadValue(anyerror)
b = 4423(anyerror!u32)
n = 4423(u32)
While: Iteration 0
While: Iteration 1
While: Iteration 2
While: Iteration 3
For: Iteration 0
For: Iteration 1
For: Iteration 2
For: Iteration 3
関数かんすう
関数かんすうはfnキーワードを使つかって宣言せんげんします。
function.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn add(a: i32, b: i32) i32 {
    return a + b;
}

pub fn main() !void {
    const result = add(5, 3);
    try stdout.print("Sum: {}\n", .{result});
}
実行じっこう結果けっか
Sum: 8
構造こうぞう体たいとメソッド
構造こうぞう体たいはstructキーワードを使つかって定義ていぎします。メソッドは構造こうぞう体たいの関数かんすうを定義ていぎすることで実現じつげんします。
struct+method.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const myCar = Car.init("Toyota", 2022);

    try stdout.print("myCar = {}\n", .{myCar});
}

const Car = struct {
    model: []const u8,
    year: u32,
    const Self = @This();
    pub fn init(model: []const u8, year: u32) Self {
        return Self{
            .model = model,
            .year = year,
        };
    }
    pub fn format(
        car: Self,
        comptime fmt: []const u8,
        options: std.fmt.FormatOptions,
        out_stream: anytype,
    ) !void {
        _ = options;
        _ = fmt;
        try out_stream.print("Car(Model: {s}, Year: {})", .{ car.model, car.year });
    }
};
実行じっこう結果けっか
myCar = Car(Model: Toyota, Year: 2022)

ここでは、Zigの基本きほん的てきな構文こうぶんとコンセプトを簡単かんたんに紹介しょうかいしました。

Hello world の変遷へんせん

[編集へんしゅう]

Zig Language Referenceの、Hello worldの変遷へんせん（新あたらしい順じゅん）。

master@2024-04-23[4]
0.8.1に同おなじ
0.12.0[5]
0.8.1に同おなじ
0.11.0[6]
0.8.1に同おなじ
0.10.0[7]
0.8.1に同おなじ
0.9.1[8]
0.8.1に同おなじ
0.8.1[9]
const std = @import("std");
pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {s}!\n", .{"world"});
}
{} ⇒ {s}[10]
0.7.1[11]
const std = @import("std");
pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {}!\n", .{"world"});
}
s/outStream/writer/
0.6.0[12]
const std = @import("std");
pub fn main() !void {
    const stdout = std.io.getStdOut().outStream();
    try stdout.print("Hello, {}!\n", .{"world"});
}
初期しょき化かの初期しょき値ちから try がなくなった。
0.4.0[13]
0.2.0に同おなじ
0.5.0[14]
const std = @import("std");
pub fn main() !void {
    // If this program is run without stdout attached, exit with an error.
    const stdout_file = try std.io.getStdOut();
    // If this program encounters pipe failure when printing to stdout, exit
    // with an error.
    try stdout_file.write("Hello, world!\n");
}
stdout_file が var から const に変更へんこうされた。
0.3.0[15]
0.2.0に同おなじ
0.2.0[16]
const std = @import("std");
pub fn main() !void {
    // If this program is run without stdout attached, exit with an error.
    var stdout_file = try std.io.getStdOut();
    // If this program encounters pipe failure when printing to stdout, exit
    // with an error.
    try stdout_file.write("Hello, world!\n");
}
0.1.1[17]
const io = @import("std").io;
pub fn main() -> %void {
    %%io.stdout.printf("Hello, world!\n");
}

特徴とくちょう

[編集へんしゅう]

Zigは、コンパイル時じに安全あんぜんで高速こうそくなシステムプログラミング言語げんごです。以下いかに、Zigの主おもな特徴とくちょうを詳くわしく説明せつめいします。

  1. 静的せいてき型付かたつけ:
    Zigは静的せいてき型付かたつけを採用さいようしています。型かたはコンパイル時じに解決かいけつされ、実行じっこう時じに型かたエラーを引ひき起おこすことがありません。また、型かた推論すいろんもサポートされています。
  2. 値ね型がた:
    Zigは、値ね型がたを採用さいようしています。これは、オブジェクトのコピーが作成さくせいされるため、値ね型がたはポインタ型がたよりも安全あんぜんで、予測よそく可能かのうな動作どうさをします。
  3. コンパイル時じメタプログラミング:
    Zigには、コンパイル時じメタプログラミングをサポートするためのcomptimeブロックがあります。これにより、コンパイル時じに計算けいさんを実行じっこうし、コンパイル時じに情報じょうほうを収集しゅうしゅうすることができます。
  4. メモリ管理かんり:
    Zigは、メモリ管理かんりについて堅牢けんろうで安全あんぜんなアプローチを採用さいようしています。メモリリークやダングリングポインタなどの問題もんだいを回避かいひするために、コンパイル時じにメモリ安全あんぜん性せいを検査けんさすることができます。
  5. モジュールシステム:
    Zigには、モジュールシステムがあります。モジュールは、依存いぞん関係かんけいを管理かんりするための仕組しくみを提供ていきょうします。
  6. ネイティブコード生成せいせい:
    Zigは、ネイティブコードを生成せいせいするコンパイラを提供ていきょうします。これにより、高速こうそくかつ効率こうりつ的てきなコードを実行じっこうすることができます。
  7. エラーハンドリング:
    Zigには、エラーハンドリング機能きのうがあります。エラーハンドリングは、C言語げんごのエラーコードや例外れいがい処理しょりのようなアプローチに比くらべて、より安全あんぜんで予測よそく可能かのうな動作どうさをすることができます。

以上いじょうが、Zigの主おもな特徴とくちょうのいくつかです。これらの特徴とくちょうにより、Zigは高速こうそくかつ安全あんぜんなシステムプログラミングを可能かのうにします。

以下いか、個別こべつの要素ようそに言及げんきゅうします。

コンパイル型がた言語げんご
１ひとつまたは複数ふくすうのソースコードをコンパイルして実行じっこうファイルを得え、それを実行じっこうします。
静的せいてき型付かたつけ
値ね・変数へんすう・関数かんすうのパラメーター・関数かんすうの戻もど値ねなどの型かたはコンパイル時じに検証けんしょうされ、型かた安全あんぜん性せいが担保たんぽされます。
例外れいがいはありません
エラー処理しょりなどのための例外れいがいはありません。この用途ようとには、関数かんすうの戻もど値ねにエラーユニオン型がたやオプショナル型がたを使つかいます。
演算えんざん子こオーバーロードはありません
演算えんざん子こは演算えんざん子こ一覧いちらん表ひょうにある通とおりにしか機能きのうしませんし、必かならずそのように機能きのうします。シフト演算えんざん子こがストリーム入出力にゅうしゅつりょくを行おこなったりはしません。
関数かんすうオーバーロードはありません
関数かんすうに与あたえられたパラメーターによって違ちがう関数かんすうが呼よび出だされることはありません。ただし、可変かへん引数ひきすうの関数かんすうは定義ていぎできます。その場合ばあいも、同おなじ関数かんすうが呼よび出だされます。
型かた推論すいろんが行おこなわれます
変数へんすう宣言せんげん時じに与あたえられた初期しょき値ち（必須ひっす）から変数へんすうの型かたを推論すいろんすることで型かたアノテーションを省略しょうりゃくできます。
ガベージコレクション
ガベージコレクションはありません。
クラスはありませんがメソッドはあります
クラスはありませんが、コンテナー( struct, union, enum )がメソッドを持もつことができます。
コンストラクターはありません
慣習かんしゅう的てきに init() と名付なづけられたメソッドがコンテナーのインスタンス化かに使つかわれます。
デストラクターはありません
慣習かんしゅう的てきに deinit() と名付なづけられたメソッドがコンテナーのインスタンスの解体かいたい処理しょりに使つかわれます。deinit() はスコープでを抜ぬける時ときに自動的じどうてきに実行じっこうされません。defer myObj.deinit(); のようにインスタンスの生成せいせい時じに解体かいたい処理しょりを登録とうろくします。
継承けいしょうはありません
タグ付つきunionやusingnamespaceを使つかうと継承けいしょうでしたいこと（＝差分さぶんプログラミング）が可能かのうですが、構文こうぶんや仕組しくみは異ことなります。
interface や protocol はありません
Java や Go の interface や Swift の protocol はありませんが、コンパイル時じにメソッドが定義ていぎされているかテストし、なければエラーにするプログラミングはできます。
名前なまえ空間くうかんの役割やくわりはコンテナーが担にないます
namespace の様ようなキーワードはありませんが、ドットシンタックス（コンテナー.識別子しきべつし や コンテナー変数へんすう.識別子しきべつし）でコンテナーが名前なまえ空間くうかんの役目やくめを果はたします。また、usingnamespace を使つかうとドットシンタックスなしに公開こうかい識別子しきべつしにアクセスできるようになります（ミックスインとも言いえます）。
ジェネリックプログラミングに対応たいおうしています
関数かんすう呼出よびだしの引数ひきすうに（コンパイル時じに既知きちの）型がたを渡わたすことができるので、ジェネリックプログラミングを行おこなうことが出来できます。
ソースファイルは匿名とくめいstruct
コンパイル単位たんいであるソースファイルは暗黙あんもくのうちに匿名とくめいstructで、組込くみこみ関数かんすう@import() が返かえす値ねを識別子しきべつしに束縛そくばくすることで名前なまえ空間くうかんを構成こうせいします。ex: const std = @import("std")
インスタンスがスコープを抜ぬけるときに実行じっこうする処理しょりを登録とうろくできます
スコープを抜ぬける理由りゆうによって、 defer と errdefer の2種類しゅるいの処理しょりを登録とうろくできます。
多おおくの制御せいぎょ構造こうぞうは式しきと文ぶんの構文こうぶんを持もちます
if, while, for の3つの制御せいぎょ構文こうぶんは、値ねを返かえす式しき構文こうぶんとブロックを持もつ文ぶん構文こうぶんの両方りょうほうを持もちます。switchは、値ねを返かえす式しき構文こうぶんしかありません。
文末ぶんまつの;（セミコロン）の省略しょうりゃくはできません
最近さいきんの新興しんこう言語げんごにして珍めずらしく ; は省略しょうりゃくできません。
ループ構文こうぶんは else 節ぶしを持もつことができます
whileとfor の2つの反復はんぷく構文こうぶんは、ループを「完走かんそう」した時ときに実行じっこうする else 節ぶしを持もつことができます。
キーワードを識別子しきべつしにできます
PL/Iのように無制限むせいげんにではなく @"else" のような形式けいしきでキーワードや数字すうじで始はじまる識別子しきべつしを使つかうことができます。
シャドウイング禁止きんし
外部がいぶスコープで使つかわれている識別子しきべつしと同おなじ識別子しきべつしを内側うちがわのスコープで使つかうことは出来できません。コンパイルエラーになります。
関数かんすうのパラメーターはイミュータブル
関数かんすうのパラメーターは、 const 宣言せんげんされた変数へんすう（＝定数ていすう）と同おなじく書換かきかえることは出来できません。

サンプルコード・ギャラリー

[編集へんしゅう]

実際じっさいにZigで書かかれたのコードを見みてみましょう。

都市とし間あいだの大圏たいけん距離きょり

[編集へんしゅう]

Ruby#ユーザー定義ていぎクラスの都市とし間あいだの大圏たいけん距離きょりを求もとめるメソッドを追加ついかした例れいを、Zigに移植いしょくしました。

都市とし間あいだの大圏たいけん距離きょり
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const GeoCoord = struct {
    longitude: f64,
    latitude: f64,

    const Self = @This();

    pub fn init(longitude: f64, latitude: f64) Self {
        return Self{
            .longitude = longitude,
            .latitude = latitude,
        };
    }

    pub fn format(
        self: Self,
        comptime fmt: []const u8,
        options: std.fmt.FormatOptions,
        out_stream: anytype,
    ) !void {
        _ = options;
        _ = fmt;
        var ew = "東経とうけい";
        var ns = "北緯ほくい";
        var long = self.longitude;
        var lat = self.latitude;
        if (long < 0.0) {
            ew = "西経せいけい";
            long = -long;
        }
        if (lat < 0.0) {
            ns = "南緯なんい";
            lat = -lat;
        }
        try out_stream.print("({s}: {}, {s}: {})", .{ ew, long, ns, lat });
    }

    pub fn distance(self: Self, other: Self) f64 {
        const math = std.math;
        const i = math.pi / 180.0;
        const r = 6371.008;
        return math.acos(math.sin(self.latitude * i) * math.sin(other.latitude * i) +
            math.cos(self.latitude * i) * math.cos(other.latitude * i) * math.cos(self.longitude * i - other.longitude * i)) * r;
    }
};

pub fn main() !void {
    const sites = comptime .{
        .{
            .name = "東京とうきょう",
            .gc = GeoCoord.init(139.7673068, 35.6809591),
        },
        .{
            .name = "シドニー・オペラハウス",
            .gc = GeoCoord.init(151.215278, -33.856778),
        },
        .{
            .name = "グリニッジ天文台てんもんだい",
            .gc = GeoCoord.init(-0.0014, 51.4778),
        },
    };
    inline for (sites) |site| {
        try stdout.print("{s}: {}\n", .{ site.name, site.gc });
    }

    try stdout.writeAll("---\n");

    inline for (sites, 0..) |a, index| {
        const b = sites[(index + 1) % sites.len];
        try stdout.print("{s} - {s}: {} [km]\n", .{ a.name, b.name, a.gc.distance(b.gc) });
    }
}
実行じっこう結果けっか
東京とうきょう: (東経とうけい: 1.397673068e+02, 北緯ほくい: 3.56809591e+01)
シドニー・オペラハウス: (東経とうけい: 1.51215278e+02, 南緯なんい: 3.3856778e+01)
グリニッジ天文台てんもんだい: (西経せいけい: 1.4e-03, 北緯ほくい: 5.14778e+01)
---
東京とうきょう - シドニー・オペラハウス: 7.823269299386704e+03 [km]
シドニー・オペラハウス - グリニッジ天文台てんもんだい: 1.69872708377249e+04 [km]
グリニッジ天文台てんもんだい - 東京とうきょう: 9.560546566490015e+03 [km]
Zig言語げんごでは、特定とくていの名前なまえで定義ていぎされた format メソッドは、標準ひょうじゅんライブラリである std.fmt を拡張かくちょうし、コレクションの固有こゆうの文字もじ列れつ化かメソッドを提供ていきょうします。Zigでは、配列はいれつ内ないに文字もじ列れつを含ふくむ配列はいれつは第だい一いち級きゅうオブジェクトではないため、ストリーム入出力にゅうしゅつりょくを拡張かくちょうする方法ほうほうが安全あんぜん性せいを考慮こうりょする上じょうで確実かくじつです。
新あたらしい機能きのうとして、0.11.0で導入どうにゅうされた「multi-object for loops」があります。この新あたらしい構文こうぶんを使用しようすると、同おなじ長ながさの複数ふくすうのシーケンスを反復はんぷく処理しょりすることができます。これにより、コードがより読よみやすくなり、メンテナンスが容易よういになります。
また、for の前まえにある inline キーワードは、コンパイル時じにループを展開てんかいすることを意味いみし、タプルの配列はいれつであることをコンパイラに伝つたえます。これにより、コンパイラがより効率こうりつ的てきなコードを生成せいせいできます。

ファイルの読出よみだし

[編集へんしゅう]

ファイルを開ひらいて内容ないようをアロケートしたバッファに読出よみだし標準ひょうじゅん出力しゅつりょくに出力しゅつりょくする例れい。

ファイルの読出よみだし
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const file = try std.fs.openFileAbsolute(
        "/etc/hosts",
        .{},
    );
    defer file.close();

    var reader = std.io.bufferedReader(file.reader());
    const in_stream = reader.reader();
    const allocator = std.heap.page_allocator;
    const file_size = try file.getEndPos();
    const contents = try in_stream.readAllAlloc(allocator, file_size);
    defer allocator.free(contents);

    try stdout.writeAll(contents);
}

このコードは、指定していされた絶対ぜったいパスにあるファイル（この場合ばあいは"/etc/hosts"）を開ひらいて、その内容ないようを標準ひょうじゅん出力しゅつりょくに書かき込こむプログラムです。以下いかに、コードの各かく部分ぶぶんの機能きのうを解説かいせつします。

  1. const std = @import("std");: 標準ひょうじゅんライブラリをインポートします。
  2. const stdout = std.io.getStdOut().writer();: 標準ひょうじゅん出力しゅつりょくのライターを取得しゅとくします。
  3. pub fn main() !void { ... }: プログラムのエントリーポイントとなるmain関数かんすうです。エラーが発生はっせいする可能かのう性せいがあるため、!void型かたが使用しようされています。
  4. const file = try std.fs.openFileAbsolute("/etc/hosts", .{});: /etc/hostsファイルを絶対ぜったいパスとして開ひらきます。tryキーワードは、関数かんすうがエラーを返かえす可能かのう性せいがあることを示しめします。
  5. defer file.close();: ファイルの処理しょりが終了しゅうりょうした後のちに、必かならずファイルを閉とじるようにします。deferキーワードは、そのスコープが終了しゅうりょうする際さいに処理しょりを実行じっこうすることを示しめします。
  6. var reader = std.io.bufferedReader(file.reader());: ファイルから読よみ取とりを行おこなうためのBufferedReaderを作成さくせいします。
  7. const in_stream = reader.reader();: BufferedReaderから読よみ取とりストリームを取得しゅとくします。
  8. const allocator = std.heap.page_allocator;: ページアロケータを使用しようしてメモリを割わり当あてるためのアロケータを定義ていぎします。
  9. const file_size = try file.getEndPos();: ファイルのサイズを取得しゅとくします。
  10. const contents = try in_stream.readAllAlloc(allocator, file_size);: ファイルの内容ないようを読よみ取とり、アロケータを使用しようしてメモリを割わり当あてます。
  11. defer allocator.free(contents);: メモリを解放かいほうするため、contentsがスコープを抜ぬけた時ときに必かならず実行じっこうされるようにします。
  12. try stdout.writeAll(contents);: ファイルの内容ないようを標準ひょうじゅん出力しゅつりょくに書かき込こみます。エラーが発生はっせいした場合ばあいには、そのエラーが処理しょりされます。

このプログラムは、指定していされたファイルの内容ないようを読よみ取とり、その内容ないようを標準ひょうじゅん出力しゅつりょくに書かき込こみます。

ジェネリックな複素数ふくそすう型がた

[編集へんしゅう]

ジェネリックプログラミングを使つかった複素数ふくそすう型がたを実装じっそうしてみました。

ジェネリックな複素数ふくそすう型がた
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const signbit = std.math.signbit;

fn Complex(comptime T: type) type {
    return struct {
        real: T,
        imag: T,

        const Self = @This();
        pub fn init(real: T, imag: T) Self {
            return Self{ .real = real, .imag = imag };
        }
        pub fn add(self: Self, other: Self) Self {
            return Self{ .real = self.real + other.real, .imag = self.imag + other.imag };
        }
        pub fn format(
            self: Self,
            comptime fmt: []const u8,
            options: std.fmt.FormatOptions,
            out_stream: anytype,
        ) !void {
            try std.fmt.formatType(self.real, fmt, options, out_stream, 1);
            if (signbit(self.imag)) {
                try out_stream.writeAll("-");
                try std.fmt.formatType(-self.imag, fmt, options, out_stream, 1);
            } else {
                try out_stream.writeAll("+");
                try std.fmt.formatType(self.imag, fmt, options, out_stream, 1);
            }
            return out_stream.writeAll("i");
        }
    };
}

pub fn main() !void {
    const F64Complex = Complex(f64);
    var f64cplx1 = F64Complex.init(3.0, 4.0);
    const f64cplx2 = F64Complex.init(1.0, -4.0);
    try stdout.print("{}\n", .{f64cplx1});
    try stdout.print("{d:.1}\n", .{f64cplx2});
    try stdout.print("{x}\n", .{f64cplx1.add(f64cplx2)});
}
実行じっこう結果けっか
3.0e+00+4.0e+00i 1.0-4.0i 
0x1p2+0x0.0p0i
pub fn Complex(comptime T: type) typeは、要素ようそ型がたをパラメーターに複素数ふくそすう型がたを返かえします（複素数ふくそすうではなく複素数ふくそすう型がたです）。
Zig には演算えんざん子こオーバーライドがないのでメソッドとして定義ていぎします。
2つの複素数ふくそすうを足たし、結果けっかを別べつの複素数ふくそすうとして返かえす add()
real+imag の形式けいしきで文字もじ列れつ化かする format()
「std/math/complex.zig」も参照さんしょう

ソート

[編集へんしゅう]

標準ひょうじゅんライブラリーのソート機能きのうの使用しよう例れい。

ソートの例れい
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var ary = [_]i8{ 1, 4, 1, 4, 2, 1, 3, 5, 6 };

    try stdout.print("befor: {any}\n", .{ary});

    std.sort.insertion(i8, &ary, {}, struct {
        pub fn cmp(context: void, a: i8, b: i8) bool {
            return std.sort.asc(i8)(context, a, b);
        }
    }.cmp);

    try stdout.print("after: {any}\n", .{ary});
}
実行じっこう結果けっか
befor: { 1, 4, 1, 4, 2, 1, 3, 5, 6 }
after: { 1, 1, 1, 2, 3, 4, 4, 5, 6 }
std.sort.insertion()は、型かた・配列はいれつ・context・比較ひかく関数かんすうをパラメーターに配列はいれつをソートします。
Zigには、ラムダ式しきがないので匿名とくめいstructのメソッドを比較ひかく関数かんすうに使つかいました。
この場合ばあいはstd.sort.insertion(i8, &ary, {}, comptime std.sort.asc(i8));で十分じゅうぶんですが
structの配列はいれつのあるフィールドをキーにソートしたい場合ばあいは、匿名とくめいstructのメソッドを比較ひかく関数かんすうに使つかう手口てぐちが有効ゆうこうですし、ソート対象たいしょうのstructのコードに手てを入いれられるときは、structのメソッドにしても良よいでしょう（ラムダ式しきほしい）。

エラトステネスの篩ふるい

[編集へんしゅう]

エラトステネスの篩ふるいを、若干じゃっかん Zig らしく書かいてみました。

エラトステネスの篩ふるい
const std = @import("std");
const stdout = std.io.getStdOut().writer();

fn Eratosthenes(comptime n: u16) !void {
    var sieve: [n + 1]bool = undefined;
    for (&sieve, 0..) |*e, i| {
        e.* = i >= 2;
    }
    for (sieve, 0..) |_, i| {
        if (!sieve[i]) {
            continue;
        }

        try stdout.print("{} ", .{i});
        var j = 2 * i;
        while (j <= n) : (j += i) {
            sieve[j] = false;
        }
    }
}

pub fn main() !void {
    try Eratosthenes(1000);
}
実行じっこう結果けっか
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997
このコードは、0.11.0以降いこうでしか動うごきません。

抽象ちゅうしょうクラス（の代替だいたい）

[編集へんしゅう]

Java/抽象ちゅうしょうクラスを、Crystalに移植いしょくしました例れいを題材だいざいに、Zigにはない抽象ちゅうしょうクラスの代替だいたいのコード例れいを書かいてみました。

抽象ちゅうしょうクラス（の代替だいたい）
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const Point = struct {
    x: i32 = 0,
    y: i32 = 0,

    const Self = @This();
    pub fn init(x: i32, y: i32) Self {
        return Self{ .x = x, .y = y };
    }
    pub fn format(
        self: Self,
        comptime fmt: []const u8,
        options: std.fmt.FormatOptions,
        out_stream: anytype,
    ) !void {
        _ = options;
        _ = fmt;
        return out_stream.print("x:{}, y:{}", .{ self.x, self.y });
    }
    pub fn move(self: Self, dx: i32, dy: i32) Self {
        self.x += dx;
        self.y += dy;
        return self;
    }
};

const Shape = struct {
    location: Point = Point.init(0, 0),

    const Self = @This();
    pub fn init(x: i32, y: i32) Self {
        return Self{ .location = Point.init(x, y) };
    }
    pub fn format(
        self: Self,
        comptime fmt: []const u8,
        options: std.fmt.FormatOptions,
        out_stream: anytype,
    ) !void {
        _ = options;
        _ = fmt;
        return out_stream.print("{}", .{self.location});
    }
    pub fn move(self: Self, dx: i32, dy: i32) Self {
        self.location.move(dx, dy);
        return self;
    }
};

const Square = struct {
    shape: Shape = Shape.init(0, 0),
    wh: i32 = 0,

    const Self = @This();
    pub fn init(x: i32, y: i32, wh: i32) Self {
        return Self{ .shape = Shape.init(x, y), .wh = wh };
    }
    pub fn format(
        self: Self,
        comptime fmt: []const u8,
        options: std.fmt.FormatOptions,
        out_stream: anytype,
    ) !void {
        _ = options;
        _ = fmt;
        return out_stream.print("{}, wh:{}", .{ self.shape, self.wh });
    }
    pub fn move(self: Self, dx: i32, dy: i32) Self {
        self.shape.move(dx, dy);
        return self;
    }
    pub fn area(self: Self) i32 {
        return self.wh * self.wh;
    }
};

const Rectangle = struct {
    shape: Shape = Shape.init(0, 0),
    width: i32 = 0,
    height: i32 = 0,

    const Self = @This();
    pub fn init(x: i32, y: i32, width: i32, height: i32) Self {
        return Self{ .shape = Shape.init(x, y), .width = width, .height = height };
    }
    pub fn format(
        self: Self,
        comptime fmt: []const u8,
        options: std.fmt.FormatOptions,
        out_stream: anytype,
    ) !void {
        _ = options;
        _ = fmt;
        return out_stream.print("{}, width:{}, height:{}", .{ self.shape, self.width, self.height });
    }
    pub fn move(self: Self, dx: i32, dy: i32) Self {
        self.shape.move(dx, dy);
        return self;
    }
    pub fn area(self: Self) i32 {
        return self.width * self.height;
    }
};

const Circle = struct {
    shape: Shape = Shape.init(0, 0),
    r: i32 = 0,

    const Self = @This();
    pub fn init(x: i32, y: i32, r: i32) Self {
        return Self{ .shape = Shape.init(x, y), .r = r };
    }
    pub fn format(
        self: Self,
        comptime fmt: []const u8,
        options: std.fmt.FormatOptions,
        out_stream: anytype,
    ) !void {
        _ = options;
        _ = fmt;
        return out_stream.print("{}, r:{}", .{ self.shape, self.r });
    }
    pub fn move(self: Self, dx: i32, dy: i32) Self {
        self.shape.move(dx, dy);
        return self;
    }
    pub fn area(self: Self) f32 {
        return @as(f32, @floatFromInt(self.r * self.r)) * std.math.pi;
    }
};

pub fn main() !void {
    const ary = comptime .{ Point.init(3, 4), Shape.init(20, 24), Rectangle.init(10, 20, 32, 24) };
    inline for (ary) |x| {
        try stdout.print("{}({})\n", .{ @TypeOf(x), x });
    }

    try stdout.writeAll("\n");

    const shapes = comptime .{ Square.init(10, 12, 40), Rectangle.init(10, 20, 32, 24), Circle.init(10, 12, 20) };
    inline for (shapes) |shape| {
        try stdout.print("{}({}).area() = {}\n", .{ @TypeOf(shape), shape, shape.area() });
    }
}
実行じっこう結果けっか
Point(x:3, y:4)
Shape(x:20, y:24)
Rectangle(x:10, y:20, width:32, height:24)

Square(x:10, y:12, wh:40).area() = 1600
Rectangle(x:10, y:20, width:32, height:24).area() = 768 
Circle(x:10, y:12, r:20).area() = 1.25663708e+03
インスタンスの文字もじ列れつ化かは、format() メソッドを定義ていぎすることで std.fmt を拡張かくちょうしています。
area() メソッドを持もつインスタンスを要素ようそとするタプルを comptime 修飾しゅうしょくした上うえで、inline な for で回まわしました。
この方法ほうほうは、コンパイル時じに全すべてのインスタンスが area() メソッドを持もつことを担保たんぽします。
ここでは各かくインスタンスの型かたが Shape を継承けいしょうしてるわけではなく専もっぱら area() メソッドを持もつことを拠より所どころにしています。
その意味いみで、interface や protocol と似にていますが、「共通きょうつうする特徴とくちょうの定義ていぎ」はしていません。

範囲はんい型がた（の代替だいたい）

[編集へんしゅう]

Zigには範囲はんい型がたがないので代替だいたいのコード例れいを書かいてみました。

範囲はんい型がた（の代替だいたい）
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const Range = struct {
    s: i32,
    e: i32,
    const Self = @This();
    pub fn init(s: i32, e: i32) Self {
        return Self{ .s = s, .e = e };
    }
    pub fn next(self: *Self) ?i32 {
        return if (self.s > self.e) null else blk: {
            const n = self.s;
            self.s += 1;
            break :blk n;
        };
    }
};

pub fn main() !void {
    var r = Range.init(23, 42);
    while (r.next()) |i| {
        try stdout.print("{} ", .{i});
    }
}
実行じっこう結果けっか
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

チートシート

[編集へんしゅう]
エントリーポイント
エラーユニオン型がたが返かえる可能かのう性せいを考慮こうりょしない場合ばあい
pub fn main() void {}
エラーユニオン型がたが返かえる可能かのう性せいを考慮こうりょする場合ばあい
pub fn main() !void {}
コメント
// から行末ゆくすえまでがコメントです。
// /* ... */ スタイルのコメントはありません。
変数へんすう宣言せんげん
イミュータブル
const 識別子しきべつし : 型かた = 初期しょき化か式しき ;
型かた推論すいろん版ばん
const 識別子しきべつし = 初期しょき化か式しき ;
ミュータブル
var 識別子しきべつし : 型かた = 初期しょき化か式しき ;
リテラル
整数せいすうリテラル
123, 0b11010, 0o177, 0xbadbeef
浮動ふどう小数点しょうすうてん数すうリテラル
3.14, 1.2e-9
文字もじリテラル
'a', '漢かん', '💯'
文字もじ列れつリテラル
”abc”, "了解りょうかい🏝👅"
複ふく数すう行ぎょうに渡わたる文字もじ列れつリテラル
\\ 複ふく数すう行ぎょうに渡わたる場合ばあいは
\\ この様ように
\\ \\ を前まえ置おけすることで
\\ 記述きじゅつできます。
配列はいれつリテラル
[4]u16{ 2,3,5,7 }, [_]u16{1,2,3,4,5}
制御せいぎょ構造こうぞう
分岐ぶんき
if
else節ぶしのないif式しき
if ( 条件じょうけん式しき ) 式しき
条件じょうけん式しきが false でなければif式しきの値ねは 式しき
false ならば void
if式しき
if ( 条件じょうけん式しき ) 式しき１ else 式しき２
条件じょうけん式しきが false でなければif式しきの値ねは 式しき１
false ならなば 式しき２
if文ぶん
if ( 条件じょうけん式しき ) {
    // ブロック
}
条件じょうけん式しきが false でなければブロックを実行じっこう
else節ふしあり
if ( 条件じょうけん式しき ) {
    // ブロック１ 
} else {
    // ブロック２
}
条件じょうけん式しきが false でなければブロック１を実行じっこう
else ならばブロック２を実行じっこう
条件じょうけん式しきがオプショナル型がた
if ( オプショナル式しき ) | 変数へんすう | {
    // ブロック１
} else {
    // ブロック２
}
オプショナル式しきが
null でなければ変数へんすうにキャプチャーしブロック１を実行じっこう
null ならばブロック２を実行じっこう
条件じょうけん式しきがエラーユニオン型がた
if ( エラーユニオン式しき ) | 変数へんすう | {
    // ブロック１
} else | err | {
    // ブロック２
}
エラーユニオン式しきが
エラーコードでなければ変数へんすうにキャプチャーしブロック１を実行じっこう
エラーコードならば err にキャプチャーしブロック２を実行じっこう
switch
switch ( 式しき ) {
    値ね１ => 式しき１,
    値ね２ａ, 値ね２ｂ => | 変数へんすう２ | 式しき２, // 変数へんすう２にキャプチャー
    値ね３ａ => | *変数へんすう３ | 式しき３, // 変数へんすう３にポインターをキャプチャー
　　elase => 式しきｘ
}
反復はんぷく
while
値ねを返かえす
var i = 1;
const q = while (i < 10) : (i += 1) {
    if (i > 5) {
        break true;
    } 
} else false;
ラベル付つき
var i: usize = 0;
outer: while (i < 10) : (i += 1) {
    while (true) {
        continue :outer;
    } 
}
オプショナル型がた
while (オプショナル式しき) | 変数へんすう | { // null でなければ変数へんすうにキャプチャー
  // ブロック１
} else { // null だったとき
  // ブロック２
}
エラーユニオン型がた
while (エラーユニオン式しき) | 変数へんすう | { // エラーコードでなければ変数へんすうにキャプチャー
  // ブロック１
} else |err| { // エラーコードを err にキャプチャー
  // ブロック２
}
for
値ねを返かえす
const items = [_]i32 { 4, 5, 3, 4, 0 };
const q = for (items) | item | {
    if (item == 5) {
        break true;
    } 
} else false;
ラベル付つき
outer: for ([_]i32 { 4, 5, 3, 4, 0 }) | x | {
    for ([_]i32 { 1, 3, 5, 7 }) | y | {
        if ( x == y ) {
            continue :outer;
        }
    }
}
コンテナー
struct
structリテラル
struct型がた{
    .メンバー１ = 式しき１,
    .メンバー２ = 式しき２,
    .メンバーｎ = 式しきｎ
}
匿名とくめいstructリテラル（タプル）
.{
    式しき１,
    式しき２,
    式しきｎ
}
enum
enumリテラル
enum型がた.メンバー
union
unionリテラル
uniont型がた{ .メンバー = 式しき }
タグ付つきunion
関数かんすう
関数かんすう定義ていぎ

基礎きそ篇へん

[編集へんしゅう]

[TODO:書かくべき項目こうもくを並ならべてみましたが、例たとえば「値ねと型かた」だけでも網羅もうら的てきに書かいていくとコンテンツの分量ぶんりょうが爆発ばくはつするのが目めに見みえているので、過剰かじょうになったらリファレンス篇へんに移動いどうするなどの方法ほうほうで、各かく節ふしはコンパクトさを心こころがけたい]

エントリーポイント

[編集へんしゅう]

Zigでは、関数かんすう mainがエントリーポイントです。

nop.zig
pub fn main() void {}

なにもしないプログラムはこの様ようになりますが、エラー集合しゅうごう型がたを返かえす可能かのう性せいがあるときは 

pub fn main() !void {
   // エラー集合しゅうごう型がたを返かえす可能かのう性せいがある処理しょり
}

と戻もど値ねの型かたを void から !void に代かえます。

コメント

[編集へんしゅう]

Zigのコメントに関かんする基本きほん的てきなポイントを要約ようやくします。

  1. 3つのコメントのタイプ: Zigでは、通常つうじょうのコメント、ドキュメントコメント、トップレベルのドキュメントコメントの3つのタイプがサポートされています。通常つうじょうのコメントは無視むしされますが、ドキュメントコメントとトップレベルのドキュメントコメントは、パッケージのドキュメントを生成せいせいするためにコンパイラによって使用しようされます。
  2. 通常つうじょうのコメント: 通常つうじょうのコメントは // で始はじまり、次つぎの改行かいぎょう文字もじ（LFバイト）までがコメントとして扱あつかわれます。
  3. ドキュメントコメント: ドキュメントコメントは、/// で始はじまります。複数ふくすうのドキュメントコメントが連続れんぞくする場合ばあい、1つの複ふく数すう行ぎょうのドキュメントコメントとして統合とうごうされます。ドキュメントコメントは、それに続つづく要素ようそを文書ぶんしょ化かします。
  4. トップレベルのドキュメントコメント: トップレベルのドキュメントコメントは、//! で始はじまります。これは、現在げんざいのモジュールを文書ぶんしょ化かします。
  5. ドキュメントコメントの位置いち: ドキュメントコメントは特定とくていの場所ばしょにのみ許可きょかされています。例たとえば、式しきの途中とちゅうや非ひドキュメントコメントの直前ちょくぜんにドキュメントコメントがある場合ばあい、コンパイルエラーになります。
  6. 通常つうじょうのコメントとの統合とうごう: 現在げんざい、パッケージのドキュメントを生成せいせいする際さいに、通常つうじょうのコメントはドキュメントコメントと統合とうごうされます。

Zigのコメントシステムは、コードの文書ぶんしょ化かと理解りかいを容易よういにするための強力きょうりょくなツールです。

通常つうじょうのコメント

[編集へんしゅう]

Zigでは、// から行末ゆくすえまでがコメントです。 C言語げんごの /* … */ のスタイルの複ふく数すう行ぎょうに渡わたるコメントはありません。 これは、コードの各行かくこうを文脈ぶんみゃくに関係かんけいなくトークン化かできるようにするためです。

hello.zig
// hello.zig:
const std = @import("std"); // 先頭せんとうに @ が付つく関数かんすうは組込くみこみ関数かんすうです
pub fn main() !void { // 次つぎの行くだりの try 演算えんざん子こがエラー集合しゅうごうを返かえす可能かのう性せいがあるので !void が戻もど値ね型がた
   try std.io.getStdOut().writeAll("Hello, World!\n");
}
Builtin Functions

Docコメント

[編集へんしゅう]

Zigでは、/// から始はじまるコメントは特別とくべつなコメントで、Docコメント( Doc comments )と呼よばれます。 Docコメントは特定とくていの場所ばしょにしか許ゆるされません。式しきの途中とちゅうや非ひDocコメントの直前ちょくぜんなど、予想よそう外がいの場所ばしょにdocコメントがあると、コンパイルエラーになります。

[TODO:サンプルコードと整形せいけい結果けっか]

トップレベルDocコメント

[編集へんしゅう]

Zigでは、//! から始はじまるコメントは特別とくべつなコメントで、トップレベルDocコメント( Top-Level Doc Comments )と呼よばれます。 コンテナレベルのドキュメントのように、直後ちょくごのドキュメントに属ぞくさないユーザードキュメントに、トップレベルDocコメントを使つかいます。

[TODO:サンプルコードと整形せいけい結果けっか]

DocコメントおよびトップレベルDocコメントは、コンパイル時じに zig build-exe -femit-docs ソースファイル.zig の様ように、-femit-docs をあたえると、 docs/ 以下いかにドキュメントが生成せいせいされます。

値ねと型かた

[編集へんしゅう]

Zigの値ねと型かたに関かんする基本きほん的てきなポイントを要約ようやくします。

値ね
  1. 整数せいすう: 整数せいすうは、i32、i64などのサイズに応おうじた型かたで表あらわされます。算術さんじゅつ演算えんざんやビット演算えんざんなどがサポートされます。
  2. 浮動ふどう小数点しょうすうてん数すう: 浮動ふどう小数点しょうすうてん数すうは、f32、f64などのサイズに応おうじた型かたで表あらわされます。浮動ふどう小数点しょうすうてん数すう演算えんざんなどがサポートされます。
  3. 真偽しんぎ値ち: trueとfalseの2つの値ねを持もつブール型がたがあります。
  4. オプション型がた: 値ねが存在そんざいするかどうかを示しめすオプション型がたがあり、nullで初期しょき化かされます。
  5. エラー統合とうごう: エラーコードまたは正常せいじょうな値ねを保持ほじするエラー統合とうごう型がたがあります。

型かた

  1. プリミティブ型がた: i32、f64、boolなどの基本きほん的てきなデータ型がたがあります。さらに、ポインターサイズの整数せいすうや特定とくていのABIに対応たいおうする型かたもあります。
  2. 任意にんいの型かた: void、anyerror、typeなど、特殊とくしゅな目的もくてきの型かたがあります。
  3. 文字もじ列れつリテラルとUnicodeコードポイントリテラル: 文字もじ列れつリテラルは定数ていすうのポインターであり、UTF-8でエンコードされた文字もじ列れつを表あらわします。Unicodeコードポイントリテラルは、UTF-8でエンコードされたUnicodeコードポイントを表あらわします。
代入だいにゅうと変数へんすう
  1. const: constキーワードを使用しようして、定数ていすうの値ねを変数へんすうに割わり当あてます。一度いちど割わり当あてられた値ねは変更へんこうできません。
  2. var: varキーワードを使用しようして、変数へんすうを宣言せんげんし、初期しょき化かして値ねを変更へんこうできるようにします。
  3. undefined: undefinedは変数へんすうを初期しょき化かせずに残のこすために使用しようされます。これは、不正ふせいな値ねを意味いみし、バグの兆候ちょうこうです。undefinedは、任意にんいの型かたに変換へんかんできますが、その後ごはその値ねが未定義みていぎであることを検出けんしゅつすることはできません。

Zigの値ねと型かたのシステムは、明確めいかくで柔軟じゅうなんなプログラミングをサポートし、安全あんぜんなコードの作成さくせいを促進そくしんします。

[TOD0:整数せいすう・浮動ふどう小数点しょうすうてん数すう・bool・文字もじ列れつ・union・struct・enum・配列はいれつ・ベクトル・スライス・ポインター・ゼロビットな型かた, 関連かんれんする組込くみこみ関数かんすう]

さまざまな値ねとその型かた

[編集へんしゅう]
formatを伴ともなうprintと値ねと型かた
pub fn main() !void {
    const stdout = @import("std").io.getStdOut().writer();
    try stdout.print(" (1) = {}\n", .{42});
    try stdout.print(" (2) = {}\n", .{0x17});
    try stdout.print(" (3) = {}\n", .{0o17});
    try stdout.print(" (4) = {}\n", .{0b0100101});
    try stdout.print(" (5) = {}\n", .{1e222});
    try stdout.print(" (6) = {}\n", .{3.1415926536});
    try stdout.print(" (7) = {}\n", .{'c'});
    try stdout.print(" (8) = {c}\n", .{'c'});
    try stdout.print(" (9) = {s}\n", .{"abcdef"});
    try stdout.print("(10) = {}, {}\n", .{ 111, 999 });
    try stdout.print("(11) = {1}, {0}\n", .{ 111, 999 });
    try stdout.print("(12) = {1s}, {0}\n", .{ 111, "abc" });
    try stdout.print("(13) = {0d}, {0b}, {0o}, {0x}, {0X}\n", .{ 123 });
}
実行じっこう結果けっか
 (1) = 42
 (2) = 23
 (3) = 15
 (4) = 37
 (5) = 1.0e+222
 (6) = 3.1415926536e+00
 (7) = 99
 (8) = c
 (9) = abcdef
(10) = 111, 999
(11) = 999, 111
(12) = abc, 111
(13) = 123, 1111011, 173, 7b, 7B
print()の前まえの、tryは単項たんこう演算えんざん子こです。
try は、右みぎの式しきのエラーユニオン式しきを評価ひょうかします。もしエラーであれば、同おなじエラーで現在げんざいの関数かんすうから戻もどます。そうでない場合ばあいは、式しきはラップされていない値ねになります。
エラーユニオン型がた( Error Union Type )を返かえす関数かんすうは、try単項たんこう演算えんざん子こかcatch二に項こう演算えんざん子こで、値ねとエラーを弁別べんべつする必要ひつようがあります（tryあるいはcatchがないと、コンパイル時じにエラーになります）。
An error occurred:
/tmp/playground726918707/play.zig:3:10: error: error is ignored. consider using `try`, `catch`, or `if`   stdout.print(" (1) = {}\n", .{42});
                                                                                                                ^
print()の様ように、標準ひょうじゅんライブラリーの format()を使つかう関数かんすうは、書式しょしき化か文字もじ列れつとタプル（匿名とくめい struct ） .{ … } を引数ひきすうにします。C言語げんごのような、可変かへん引数ひきすうではなくタプルを使つかうので[18]、プレースホルダーがない場合ばあいでも、空そらのタプル.{} は必須ひっすです。
書式しょしき化か文字もじ列れつ
通常つうじょうの文字もじ列れつですが { と } で囲かこまれたプレスホルダーが、タプルの当該とうがい順位じゅんいの値ね（を書式しょしき化かした文字もじ列れつ）に置換おきかわります。
書式しょしき化か文字もじ列れつの中なかで { あるいは } 自身じしんを使つかいたいときには、{{ あるいは }} と二に文字もじ重かさねます。
タプル
書式しょしき化か文字もじ列れつのプレースホルダーによって、参照さんしょうと文字もじ列れつ化かされる値ねのタプルです。
2つ以上いじょうの値ねを渡わたす場合ばあいは、第だい二に引数ひきすうを .{ 1, 2, 3 } の様ようにカンマ区切くぎりのタプルにします（ {} の前まえの . （点てん）を忘わすれがちですが、型かたの省略しょうりゃくを意味いみし必須ひっすです）。
基本きほん的てきに、左ひだりから順じゅんにプレスホルダーにタプルの値ねが左ひだりから与あたえられますが、{0} {1} の書式しょしきで参照さんしょうする引数ひきすうの順位じゅんいを明示めいじできます。
書式しょしき指定していと併用へいようする時ときは、 stdout.print("? = {1s}, {0}\n", .{ 111, "abc" }) の様ように順位じゅんいが先さき、書式しょしき指定してい文字もじが後のちになります。
この機能きのうは言語げんご（自然しぜん言語げんご）によって異ことなる語順ごじゅんを吸収きゅうしゅうすることに使つかえそうですが、fmtの第だい一いち引数ひきすうは comptime 修飾しゅうしょく子こがついていて変数へんすうにはできません。
数値すうち（整数せいすうと浮動ふどう小数点しょうすうてん数すう）や文字もじリテラルと文字もじ列れつリテラルがあり、整数せいすうはいくつかの異ことなる基数きすう表現ひょうげんが、浮動ふどう小数点しょうすうてん数すうは指数しすう表現ひょうげんと小数しょうすう表現ひょうげんがあります。
文字もじと文字もじ列れつは明確めいかくに異ことなり、リテラルでは ’A’ が文字もじ（@TypeOf('A') ⇒ comptime_int）、 ”ABC” が文字もじ列れつ（@TypeOf("ABC") ⇒ *const [3:0]u8）です。
嫌いやな予感よかんがした人ひとの直感ちょっかんは正解せいかいです。Zig では、文字もじ列れつは第だい一いち級きゅうオブジェクトではなく文字もじ（u8）の配列はいれつで、関数かんすうから返かえすときはアロケーターと defer の連携れんけいなどで記憶きおく域いきの寿命じゅみょうと値ねの妥当だとう性せいを「プログラマー」が担保たんぽする必要ひつようがあります。また、GoのGCはありません。CrystalのASTを操作そうさできるマクロもありませんし、Rustの所有しょゆう権けんも、C++のスマートポインターもありません。
このことは、C言語げんごなみのプログラマー任まかせのメモリー管理かんりを文字もじ列れつ以外いがいでも強しいられることを意味いみしていますが、zig（コマンド）や標準ひょうじゅんライブラリーのソースコードを読よむと、複数ふくすうの型かたでアロケーターを使つかい分わけ、スタック上じょうのインスタンス（のハードウェア起因きいんのスコープ）を使つかい分わけられることを実践じっせんで証明しょうめいしているので、pre-releaseから、initial-releasまでの間あいだに、安定あんてい化か・定式ていしき化かが図はかられることを期待きたいします。

[TODO:master/lib/std/fmt.zigを観みて書かいています。参照さんしょうすべき標準ひょうじゅんライブラリーのドキュメントを出来できたら/仕様しようが安定あんていしたら見直みなおし]

プリミティブ型がた

[編集へんしゅう]
プリミティブ型がた( Primitive Types )[19]
型かた 相当そうとうするC言語げんごの型かた 説明せつめい
i8 int8_t 符号ふごう付つき8ビット整数せいすう
u8 uint8_t 符号ふごう無なし8ビット整数せいすう
i16 int16_t 符号ふごう付つき16ビット整数せいすう
u16 uint16_t 符号ふごう無なし16ビット整数せいすう
i32 int32_t 符号ふごう付つき32ビット整数せいすう
u32 uint32_t 符号ふごう無なし32ビット整数せいすう
i64 int64_t 符号ふごう付つき64ビット整数せいすう
u64 uint64_t 符号ふごう無なし64ビット整数せいすう
i128 __int128 符号ふごう付つき128ビット整数せいすう
u128 unsigned __int128 符号ふごう無なし128ビット整数せいすう
isize intptr_t 符号ふごう付つきポインターサイズ整数せいすう
usize uintptr_t, size_t 符号ふごう無なしポインターサイズ整数せいすう
c_short short C言語げんごとのABI互換ごかん性せいのため
c_ushort unsigned short C言語げんごとのABI互換ごかん性せいのため
c_int int C言語げんごとのABI互換ごかん性せいのため
c_uint unsigned int C言語げんごとのABI互換ごかん性せいのため
c_long long C言語げんごとのABI互換ごかん性せいのため
c_ulong unsigned long C言語げんごとのABI互換ごかん性せいのため
c_longlong long long C言語げんごとのABI互換ごかん性せいのため
c_ulonglong unsigned long long C言語げんごとのABI互換ごかん性せいのため
c_longdouble long double C言語げんごとのABI互換ごかん性せいのため
f16 _Float16 16ビット浮動ふどう小数点しょうすうてん数すう（仮数かすう10ビット） IEEE-754-2008 binary16
f32 float 32ビット浮動ふどう小数点しょうすうてん数すう（仮数かすう23ビット） IEEE-754-2008 binary32
f64 double 64ビット浮動ふどう小数点しょうすうてん数すう（仮数かすう52ビット） IEEE-754-2008 binary64
f80 double 80ビット浮動ふどう小数点しょうすうてん数すう（仮数かすう64ビット） IEEE-754-2008 80ビット拡張かくちょう精度せいど
f128 _Float128 128ビット浮動ふどう小数点しょうすうてん数すう（仮数かすう112ビット） IEEE-754-2008 binary64
bool bool true または false
anyopaque void 型かた消去しょうきょされたポインター
void （該当がいとうなし） 0ビット型がた
noreturn （該当がいとうなし） break, continue, return, unreachable, and while (true) {} の型かた
type （該当がいとうなし） 型かたの型かた
anyerror （該当がいとうなし） エラーコード
comptime_int （該当がいとうなし） コンパイル時じに既知きちの値ねに対たいしてのみ許可きょかされる整数せいすうリテラルの型かた。
comptime_float （該当がいとうなし） コンパイル時じに既知きちの値ねに対たいしてのみ許可きょかされる浮動ふどう小数点しょうすうてんリテラルの型かた。
上記じょうきの整数せいすう型がたに加くわえ、任意にんいのビット幅はばの整数せいすうを参照さんしょうするには、識別子しきべつしとしてiまたはuに続つづけて数字すうじを用もちいることができます。例たとえば、識別子しきべつし i7 は符号ふごう付つき7ビット整数せいすうを意味いみします。この表現ひょうげんの整数せいすう型がたに許ゆるされる最大さいだいビット幅はばは65535です。

プリミティブ値ち

[編集へんしゅう]
プリミティブ型がた( Primitive Values )[20]
名前なまえ 説明せつめい
true と false bool 値ね
null optional型がたを null に設定せっていするために使用しようされます。
undefined 値ねを不定ふていにするために使用しようされます。

文字もじ列れつリテラルとUnicodeコードポイントリテラル

[編集へんしゅう]
構文こうぶん(EBNF)
STRINGLITERALSINGLE = "\"" string_char* "\"" skip
STRINGLITERAL = STRINGLITERALSINGLE
              | ( line_string                skip )+

ox80_oxBF = [#x80-#xBF]
oxF4 = '\xF4'
ox80_ox8F = [#x80-#x8F]
oxF1_oxF3 = [#xF1-#xF3]
oxF0 = '\xF0'
ox90_0xBF = [#x90-#xBF]
oxEE_oxEF = [#xEE-#xEF]
oxED = '\xED'
ox80_ox9F = [#x80-#x9F]
oxE1_oxEC = [#xE1-#xEC]
oxE0 = '\xE0'
oxA0_oxBF = [#xA0-#xBF]
oxC2_oxDF = [#xC2-#xDF]

(* From https://lemire.me/blog/2018/05/09/how-quickly-can-you-check-that-a-string-is-valid-unicode-utf-8/ *)
mb_utf8_literal = oxF4      ox80_ox8F ox80_oxBF ox80_oxBF
                | oxF1_oxF3 ox80_oxBF ox80_oxBF ox80_oxBF
                | oxF0      ox90_0xBF ox80_oxBF ox80_oxBF
                | oxEE_oxEF ox80_oxBF ox80_oxBF
                | oxED      ox80_ox9F ox80_oxBF
                | oxE1_oxEC ox80_oxBF ox80_oxBF
                | oxE0      oxA0_oxBF ox80_oxBF
                | oxC2_oxDF ox80_oxBF

ascii_char_not_nl_slash_squote = [\000-\011\013-\046-\050-\133\135-\177]

char_escape = "\\x" hex hex
            | "\\u{" hex+ "}"
            | "\\" [nr\\t'"]
char_char = mb_utf8_literal
          | char_escape
          | ascii_char_not_nl_slash_squote
string_char = char_escape
            |  [^\\"\n]

line_string = ( "\\\\" [^\n]* [ \n]* )+
[21]
文字もじ列れつリテラル
[編集へんしゅう]

文字もじ列れつリテラルは、ヌル終端しゅうたんバイト配列はいれつへの定数ていすう型がた単一たんいつ項目こうもくポインターです。文字もじ列れつリテラルの型かたは、長ながさとヌル終端しゅうたんであるという事実じじつの両方りょうほうをコード化かしているため、スライスとヌル終端しゅうたんポインターの両方りょうほうに強制きょうせいすることが可能かのうです。文字もじ列れつリテラルを再さい参照さんしょうすると配列はいれつに変換へんかんされます[22]。

Zigにおける文字もじ列れつのエンコーディングは、事実じじつ上じょうUTF-8であると仮定かていされています。ZigのソースコードはUTF-8でエンコードされているので、ソースコードの文字もじ列れつリテラル内ないに現あらわれる非ひASCIIバイトは、そのUTF-8の意味いみをZigのプログラム内ないの文字もじ列れつの内容ないように引ひき継つぎ、コンパイラーがそのバイトを修正しゅうせいすることはありません。ただし、UTF-8以外いがいのバイトを文字もじ列れつリテラルに埋うめ込こむことは可能かのうで、その場合ばあいは \xNN 記法きほうを使用しようします[22]。

Unicodeコードポイントリテラル
[編集へんしゅう]

Unicodeコードポイントリテラルの型かたは comptime_int で整数せいすうリテラルと同おなじです。すべてのエスケープシーケンスは、文字もじ列れつリテラルと Unicodeコードポイントリテラルの両方りょうほうにおいて有効ゆうこうです[22]。

他たの多おおくのプログラミング言語げんごでは、Unicodeコードポイントリテラルは「文字もじリテラル」と呼よばれます。しかし、Unicode仕様しようの最近さいきんのバージョン（Unicode 13.0時点じてん）では、「文字もじ」の正確せいかくな技術ぎじゅつ的てき定義ていぎは存在そんざいしません。Zigでは、Unicodeコードポイントリテラルは、Unicodeのコードポイントの定義ていぎに対応たいおうします。

エスケープシーケンス
[編集へんしゅう]
エスケープシーケンス( Escape Sequences )[23]
エスケープシーケンス 名称めいしょう
\n Newline
\r Carriage Return
\t 水平すいへいタブ
\\ バックスラッシュ自身じしん
\' シングルクォーテーション
\" ダブルクォーテーション
\xNN 16進しん8ビットバイト値ち（２桁けた）
\u{NNNNNN} 16進数しんすう Unicode コードポイント UTF-8 符号ふごう化か（1桁けた以上いじょう）
註：有効ゆうこうなUnicodeポイントの最大さいだい値ちは0x10ffffです。
マルチライン文字もじ列れつリテラル
[編集へんしゅう]

マルチライン文字もじ列れつリテラルは、エスケープが必要ひつようなく、複数ふくすうの行くだりにわたって記述きじゅつすることができます。マルチライン文字もじ列れつリテラルを始はじめるには、\\ トークンを使用しようします。コメントと同様どうように、文字もじ列れつリテラルは行くだりの末尾まつびまで続つづきます。行末ゆくすえは文字もじ列れつリテラルに含ふくまれません。ただし、次つぎの行くだりが \\ で始はじまる場合ばあい、改行かいぎょうが追加ついかされ、文字もじ列れつリテラルが続つづきます。

マルチライン文字もじ列れつリテラル
const stdout = @import("std").io.getStdOut().writer();
const message =
    \\文字もじ列れつリテラルを、エスケープ記号きごうがなく複ふく数すう行ぎょうにまたがって書かくことができます。
    \\複ふく数すう行ぎょうの文字もじ列れつリテラルを開始かいしするには、\\ トークンを使用しようします。
    \\コメントと同おなじように、文字もじ列れつリテラルは行末ゆくすえまで続つづきます。
    \\行ぎょうの終おわりは文字もじ列れつリテラルに含ふくまれません。
    \\ただし、次つぎの行くだりが \\ で始はじまる場合ばあいは、改行かいぎょうが追加ついかされ文字もじ列れつリテラルが続行ぞっこうされます。
;

pub fn main() !void {
    try stdout.print("message = {s}", .{message});
}
実行じっこう結果けっか
message = 文字もじ列れつリテラルを、エスケープ記号きごうがなく複ふく数すう行ぎょうにまたがって書かくことができます。
複ふく数すう行ぎょうの文字もじ列れつリテラルを開始かいしするには、\\ トークンを使用しようします。
コメントと同おなじように、文字もじ列れつリテラルは行末ゆくすえまで続つづきます。
行くだりの終おわりは文字もじ列れつリテラルに含ふくまれません。
ただし、次つぎの行くだりが \\ で始はじまる場合ばあいは、改行かいぎょうが追加ついかされ文字もじ列れつリテラルが続行ぞっこうされます

代入だいにゅう

[編集へんしゅう]

Zigにおける代入だいにゅうに関かんする説明せつめいの要旨ようしは以下いかの通とおりです。

  • const キーワードを使用しようして、識別子しきべつしに値ねを割わり当あてます。
  • const で定義ていぎされた識別子しきべつしは変更へんこうできません。その値ねは定数ていすうです。
  • 変数へんすうとして値ねを変更へんこうできるようにするには、var キーワードを使用しようします。
  • 変数へんすうは初期しょき化かされる必要ひつようがあります。初期しょき化かされていない変数へんすうを使用しようすると、コンパイルエラーが発生はっせいします。
  • 初期しょき化かされていない変数へんすうには undefined を使用しようして、未定義みていぎのままにすることができます。
  • 定数ていすう式しきや単純たんじゅん型がたの型かた推論すいろんには comptime を使用しようします。

具体ぐたい的てきなコード例れいは以下いかの通とおりです。 

const print = @import("std").debug.print;

// constを使つかって定数ていすうを定義ていぎ
const x = 1234;
pub fn main() void {

    // 関数かんすう内ないでのconstは定数ていすうを定義ていぎ
    const y = 5678;

    // 定数ていすうには値ねを再割さいわり当あてできない
    // y = 1;  // コンパイルエラー

    // varを使つかって変数へんすうを定義ていぎ
    var z: i32 = 5678;

    // 変数へんすうに値ねを再割さいわり当あて
    z += 1;

    // 変数へんすうは初期しょき化かする必要ひつようがある
    // var w: i32;

    comptime var w = 1; // 初期しょき化かを伴ともなった宣言せんげんは型かた推論すいろんされる

    // 変数へんすうを undefined で初期しょき化か
    var u: i32 = undefined;
    u = 8;

    print("{d}\n", .{x}); // 1234
    print("{d}\n", .{y}); // 5678
    print("{d}\n", .{z}); // 5679
    print("{d}\n", .{w}); // 1
    print("{d}\n", .{u}); // 8
}

上記じょうきのコードを実行じっこうすると、それぞれの変数へんすうや定数ていすうの挙動きょどうを確認かくにんできます。

comptime

[編集へんしゅう]

comptimeは、Zig言語げんごにおいてコンパイル時じに式しきが評価ひょうかされることを示しめします。この概念がいねんは、ジェネリック、定数ていすう式しきの評価ひょうか、コンパイル時じの最適さいてき化か、およびコンパイル時じの静的せいてき解析かいせきにおいて重要じゅうような役割やくわりを果はたします。

以下いかに、comptimeの詳細しょうさいを説明せつめいします：

  1. コンパイル時じパラメータ (Compile-Time Parameters): Zigでは、関数かんすうや構造こうぞう体たいの型かた引数ひきすうにcomptimeを使用しようすることができます。これにより、関数かんすうや構造こうぞう体たいが特定とくていの型かたに対たいしてコンパイル時じに振ふる舞まうことが保証ほしょうされます。コンパイル時じに型かたが解決かいけつされるため、特定とくていの型かたに特とく化かしたコードを生成せいせいすることができます。 
    fn example(comptime T: type) T {
    // Tの特定とくていの型かたに基もとづいた処理しょりを行おこなう
}
  2. コンパイル時じ変数へんすう (Compile-Time Variables): comptime修飾しゅうしょく子こを使用しようして、コンパイル時じに評価ひょうかされることが保証ほしょうされた変数へんすうを宣言せんげんすることができます。これらの変数へんすうは、コンパイル時じの静的せいてき解析かいせきに使用しようされ、ランタイムでのアクセスは許可きょかされません。 
    const comptime MAX_VALUE: usize = 100;
  3. コンパイル時じ式しき (Compile-Time Expressions): comptimeブロック内ないで式しきを記述きじゅつすることで、その式しきがコンパイル時じに評価ひょうかされることを保証ほしょうできます。このような式しきは、コンパイル時じのみに影響えいきょうを与あたえる必要ひつようがある場合ばあいに使用しようされます。例たとえば、配列はいれつのサイズや定数ていすうの計算けいさんに使用しようされます。 
    const arraySize = comptime 10;
const comptime result = someFunction();
  4. コンパイル時じ制御せいぎょフロー (Compile-Time Control Flow): if, while, for, switchステートメントなどの制御せいぎょフローは、コンパイル時じに評価ひょうかされることが保証ほしょうされます。これにより、特定とくていの条件じょうけんに基もとづいてコンパイル時じに異ことなるコードパスを取とることができます。 
    comptime if (someCondition) {
    // このブロックはコンパイル時じに評価ひょうかされる
} else {
    // このブロックもコンパイル時じに評価ひょうかされる
}

comptimeの使用しようにより、Zig言語げんごではコンパイル時じに高度こうどな静的せいてき解析かいせきが実行じっこうされ、パフォーマンスの向上こうじょうやコードの安全あんぜん性せいが確保かくほされます。

このコードはコンパイルエラーになります。

定数ていすうの初期しょき値ちが関数かんすうの戻もど値ねだとエラー
fn mul(x: usize, y: usize) usize {
    return x * y;
}

pub fn main() void {
    const len : usize = mul(3, 4);
    const ary: [len]i32 = undefined;
    _ = ary;
}
コンパイル結果けっか
An error occurred:
playground/playground3656639701/play.zig:7:17: error: unable to resolve comptime value
playground/playground3656639701/play.zig:7:17: note: array length must be comptime-known

エラーメッセージの意味いみは以下いかの通とおりです：

  • error: unable to resolve comptime value: コンパイル時じに解決かいけつできない値ねがあります。
  • note: array length must be comptime-known: 配列はいれつの長ながさはコンパイル時じに既知きちである必要ひつようがあります。つまり、配列はいれつの長ながさは実行じっこう時じに決定けっていされることは許ゆるされません。

つまり、Zigでは配列はいれつの長ながさなどの定数ていすう値ちはコンパイル時じに解決かいけつできる必要ひつようがあります。そのため、関数かんすうの戻もどり値ちのように実行じっこう時じに決定けっていされる値ねを定数ていすうの初期しょき値ちとして使用しようすることはできません。

C++であれば、constexpr が適用てきようなケースですが、Zigでは次つぎのような解決かいけつ方法ほうほうを取とります。下記かきコードはエラーになりません。

comptimeを追加ついかしコンパイル時じに実行じっこう
fn mul(x: usize, y: usize) usize {
    return x * y;
}

pub fn main() void {
    const len : usize = comptime mul(3, 4); // mul の前まえに comptime を追加ついか
    const ary: [len]i32 = undefined;
    _ = ary;
}
変更へんこう点てんは mul() の呼出よびだしを comptime で修飾しゅうしょくしただけです。comptime は、修飾しゅうしょく子こ式しきをコンパイル時じに実行じっこうする修飾しゅうしょく子こで、式しきの中なかでコンパイル時じに未定みていな値ねが参照さんしょうされると、エラーとなります。ここでは、数かずリテラル同士どうしの商しょうを求もとめているので、コンパイル時じ値ちが確定かくていできます。
_ = ary は、「未み使用しよう変数へんすう」をサプレッスするときのイディオムです。

テストフレームワーク

[編集へんしゅう]

Zigは、言語げんご仕様しようとツールチェインの両方りょうほうでテストをサポートしています。 Zigのテストフレームワークは、テストを実行じっこうし、アサーションを評価ひょうかし、カバレッジレポートを生成せいせいするための機能きのうを提供ていきょうします。

以下いかは、Zigのテストに関かんする概要がいようです。

  1. テスト宣言せんげん: テストは、testキーワードに続つづいて名前なまえ（オプション）とテストの本体ほんたいを含ふくむブロックで構成こうせいされます。これにより、コードの特定とくていの部分ぶぶんや関数かんすうが期待きたいどおりに動作どうさするかを検証けんしょうできます。
  2. テスト実行じっこう: zig testコマンドを使用しようしてテストを実行じっこうします。このコマンドは、テスト用ようのビルドを作成さくせいし、デフォルトのテストランナーを実行じっこうします。テストランナーは、テスト宣言せんげんを見みつけて実行じっこうし、その結果けっかを出力しゅつりょくします。
  3. テスト結果けっかの報告ほうこく: テストランナーは、テスト結果けっかを標準ひょうじゅんエラーに出力しゅつりょくします。成功せいこうしたテスト、失敗しっぱいしたテスト、スキップされたテストなどの情報じょうほうが報告ほうこくされます。これにより、開発かいはつ者しゃはテストの状態じょうたいを把握はあくし、問題もんだいがある場合ばあいは修正しゅうせいできます。
  4. テストのスキップ: error.SkipZigTestを返かえすことでテストをスキップすることができます。また、zig testコマンドに--test-filterオプションを指定していして、特定とくていのテストのみを実行じっこうすることもできます。
  5. テストの自動じどう化か: テストはコードの一部いちぶとして記述きじゅつされるため、変更へんこうがあるたびに手動しゅどうで実行じっこうする必要ひつようがありません。CI/CDパイプラインなどの自動じどう化かツールと統合とうごうして、コードの品質ひんしつを継続けいぞく的てきに確認かくにんできます。

Zigのテストフレームワークは、コードの信頼しんらい性せいを向上こうじょうさせ、開発かいはつプロセスを効率こうりつ化かするのに役立やくだちます。テストは、バグを早期そうきに発見はっけんし、コードの安定あんてい性せいを確保かくほするのに不可欠ふかけつな要素ようそです。

テスト宣言せんげんの構文こうぶん(EBNF)
test-decl = [ doc_comment ] "test" [ STRINGLITERALSINGLE ] block
[21]
if-test.zig
const std = @import("std");
const expectEqual = std.testing.expectEqual;

test "if expr" {
    const f = true;
    var x: usize = 5;
    x += if (f) 10 else 20;
    try expectEqual(x, 15);
}

test "if stmt" {
    const f = true;
    var x: isize = 10;
    if (!f) {
        x += 10;
    } else {
        x -= 20;
    }
    try expectEqual(x, -10);
}
コマンドライン
% zig test if-test.zig
All 2 tests passed.

このZigのテストコードは、 if 式しきと if 文ぶんの振ふる舞まいをテストしています。

  • "if expr": if 式しきを使用しようして、条件じょうけんに応おうじて異ことなる値ねを返かえし、その結果けっかを変数へんすうに代入だいにゅうしています。その後ご、変数へんすうの値ねが期待きたい通どおりであることを確認かくにんします。
  • "if stmt": if 文ぶんを使用しようして、条件じょうけんに応おうじて異ことなるステートメントを実行じっこうし、その結果けっかを変数へんすうに代入だいにゅうしています。その後ご、変数へんすうの値ねが期待きたい通どおりであることを確認かくにんします。

テスト結果けっかは、両方りょうほうのテストが成功せいこうし、期待きたい通どおりの結果けっかが得えられたことを示しめしています。つまり、条件じょうけん式しきが正ただしく評価ひょうかされ、それに基もとづいて適切てきせつな操作そうさが行おこなわれました。

このように、Zigのテストフレームワークを使用しようすることで、さまざまな条件下じょうけんかでのプログラムの振ふる舞まいを自動的じどうてきにテストし、コードの信頼しんらい性せいを高たかめることができます。

fdiv-inf-nan.zig
const std = @import("std");
const expect = std.testing.expect;

fn fdiv(n: f64, d: f64) f64 {
    return n / d;
}

const inf = std.math.inf(f64);
const nan = std.math.nan(f64);

test "fdiv 1" {
    try expect(fdiv(123.0, 111.1) == 123.0 / 111.1);
}

test "fdiv 2" {
    try expect(fdiv(123.0, 0.0) == inf);
}

test "fdiv 3" {
    try expect(fdiv(0.0, 0.0) == nan);
}
コマンドライン
% zig version
0.11.0
% zig test fdiv-inf-nan.zig 
Test [3/3] test.fdiv 3... FAIL (TestUnexpectedResult)
/usr/local/lib/zig/std/testing.zig:515:14: 0x2248df in expect (test)
    if (!ok) return error.TestUnexpectedResult;
             ^
/usr/home/user1/tut/zig/fdiv-inf-nan.zig:20:5: 0x224b0b in test.fdiv 3 (test)
    try expect(fdiv(0.0, 0.0) == nan);
    ^
2 passed; 0 skipped; 1 failed.
error: the following test command failed with exit code 1:
/home/user1/.cache/zig/o/00aa6779b54996b883ad0fc42233ea3d/test

この例れいでは、Zig言語げんごで fdiv-inf-nan.zig というファイルに記述きじゅつされたテストコードが示しめされています。このコードは、fdiv 関数かんすうに対たいする3つのテストケースを含ふくんでいます。

  • "fdiv 1": 正常せいじょうな割わり算ざんが行おこなわれることを確認かくにんします。fdiv(123.0, 111.1) が 123.0 / 111.1 と等ひとしいかどうかを期待きたいします。
  • "fdiv 2": 0で割わった場合ばあい、無限むげん大だいを返かえすことを確認かくにんします。fdiv(123.0, 0.0) が inf と等ひとしいかどうかを期待きたいします。
  • "fdiv 3": 0を0で割わった場合ばあい、非ひ数かずを返かえすことを確認かくにんします。fdiv(0.0, 0.0) が nan と等ひとしいかどうかを期待きたいします。

テストを実行じっこうすると、2つのテストがパスし、1つのテストが失敗しっぱいします。失敗しっぱいしたテストケースは "fdiv 3" です。このテストは、 fdiv(0.0, 0.0) が nan と等ひとしいかどうかを検証けんしょうしますが、実際じっさいにはそうではありませんでした。

この失敗しっぱいは、期待きたいされる結果けっかと実際じっさいの結果けっかが一致いっちしなかったことを示しめしています。この情報じょうほうを元もとに、fdiv 関数かんすうの実装じっそうやテストコードを再さい検討けんとうすることで、この問題もんだいを修正しゅうせいすることができます。

fdiv-inf-nan-FIX.zig
const std = @import("std");
const expect = std.testing.expect;

fn fdiv(n: f64, d: f64) f64 {
    return n / d;
}

const inf = std.math.inf(f64);
const nan = std.math.nan(f64);
const isNan = std.math.isNan;

test "fdiv 1" {
    try expect(fdiv(123.0, 111.1) == 123.0 / 111.1);
}

test "fdiv 2" {
    try expect(fdiv(123.0, 0.0) == inf);
}

test "fdiv 3" {
    try expect(isNan(fdiv(0.0, 0.0)));
}
コマンドライン
% zig test fdiv-inf-nan-FIX.zig 
All 3 tests passed.

修正しゅうせいされた fdiv-inf-nan-FIX.zig ファイルでは、3番目ばんめのテストケースが修正しゅうせいされています。その変更へんこう箇所かしょと結果けっかについて解説かいせつします。

この修正しゅうせいでは、fdiv(0.0, 0.0) の結果けっかが nan であるかどうかを確認かくにんするために、 std.math.isNan 関数かんすうを使用しようしています。この関数かんすうは、与あたえられた浮動ふどう小数点しょうすうてん数すうが非ひ数かず (nan) であるかどうかを判定はんていします。

修正しゅうせい後ごのコードを実行じっこうすると、全すべてのテストケースが成功せいこうし、期待きたい通どおりの結果けっかが得えられました。

この修正しゅうせいにより、fdiv 関数かんすうが非ひ数かず (nan) を返かえす場合ばあいに正常せいじょうにテストが通とおるようになりました。

変数へんすう

[編集へんしゅう]

Zigでは、変数へんすうは名前なまえを持もった連続れんぞくしたメモリー領域りょういきで、型かたを持もちます。 変数へんすうは、宣言せんげんが必要ひつようです。

  1. 変数へんすうの宣言せんげん:
    var キーワードまたは const キーワードを使用しようして変数へんすうを宣言せんげんします。const を使用しようすることが一般いっぱん的てきであり、これによりコードの読よみやすさが向上こうじょうし、最適さいてき化かの機会きかいが増ふえます。
  2. 外部がいぶの変数へんすうへのリンク:
    extern キーワードや @extern 組くみ込こみ関数かんすうを使用しようして、他たのオブジェクトからエクスポートされた変数へんすうとリンクすることができます。
  3. 識別子しきべつし:
    変数へんすうの識別子しきべつしは、アルファベットまたはアンダースコアで始はじまり、その後ごに任意にんいの数かずの英数字えいすうじまたはアンダースコアが続つづきます。また、キーワードとの重複じゅうふくは許ゆるされません（エスケープする方法ほうほうはあります）。⇒ 識別子しきべつし
  4. コンテナレベルの変数へんすう:
    コンテナレベルの変数へんすうは、静的せいてきなライフタイムを持もち、コンテナ内ないで宣言せんげんされるため、コンテナが評価ひょうかされると初期しょき化かされます。これらは、構造こうぞう体たい、共用きょうよう体たい、列挙れっきょ型がた、または不透明ふとうめいな型かたの内部ないぶで宣言せんげんすることができます。
  5. 静的せいてきローカル変数へんすう:
    関数かんすう内ないでコンテナを使用しようすることで、静的せいてきなローカル変数へんすうを作成さくせいすることも可能かのうです。
  6. スレッドローカル変数へんすう:
    threadlocal キーワードを使用しようして、スレッドごとに異ことなる変数へんすうインスタンスを作成さくせいすることができます。
  7. ローカル変数へんすう:
    関数かんすう内ないや comptime ブロック内ないで使用しようされる変数へんすうは、ローカル変数へんすうと呼よばれます。これらは、関数かんすうやブロックのスコープ内ないでのみ有効ゆうこうです。
  8. コンパイル時じ変数へんすう:
    comptime キーワードを使用しようすることで、コンパイル時じに値ねがわかる変数へんすうを定義ていぎすることができます。

Zig言語げんごでは、これらの変数へんすうのタイプやスコープを利用りようして、効率こうりつ的てきで安全あんぜんなプログラミングが可能かのうです。

型かたを保持ほじするconst変数へんすう

[編集へんしゅう]

Zigでは型かたに名前なまえを付つけるためにも変数へんすうが使つかわれます。

型かたを保持ほじするconst変数へんすうの例れい
const Complex = struct {
    real: f64,
    imag: f64,
};

const Colour = enum {
    red,
    green,
    blue,
};

const Number = union {
    int: i64,
    float: f64,
};

構文こうぶん

[編集へんしゅう]
構文こうぶん(EBNF)
var-decl = ( "const" | "var" ) IDENTIFIER [ ":" type-expr ] [ byte-align ] [ link-section ] [ "=" expr ] ";"
[21]
実際じっさいは const は、型かたが省略しょうりゃくでき、var は、型かたが省略しょうりゃくできず、両方りょうほうとも初期しょき化かが必須ひっすないので[24]
var-decl = const-var-decl | var-var-decl
const-var-decl = "const" IDENTIFIER [ ":" type-expr ] [ byte-align ] [ link-section ] "=" expr ";"
var-var-decl = "var" IDENTIFIER ":" type-expr [ byte-align ] [ link-section ] "=" expr ";"
と意味いみ論ろんも加味かみするとなります。
var 変数へんすうの場合ばあいは、不ふ定値ていちとしてプリミティブ値ちの undefined で初期しょき化かすることができます[25]。
undefinedは、任意にんいの型かたに強制きょうせい( be coerced )することができます。一旦いったんこれが起おこると、値ねがundefinedであることを検出けんしゅつすることができなくなります。 undefinedは、値ねが何なににでもなり得えることを意味いみし、型かたによれば無意味むいみなものでさえもあり得えることを意味いみします。英語えいごで undefinedは "Not a meaningful value. Using this value would be a bug. The value will be unused, or overwritten before being used."（意味いみのない値ね。この値ねを使つかうとバグになる。この値ねは使つかわれないか、使つかわれる前まえに上書うわがきされるでしょう）という意味いみです（ただしローカル変数へんすうが使つかわれないと、error: unused local variable となります）。

const 変数へんすう

[編集へんしゅう]

キーワード const で宣言せんげんされた変数へんすうは、必かならず初期しょき化かが必要ひつようで、宣言せんげん以降いこうは値ねを変更へんこうすることはできません（イミュータブル）。 const 変数へんすうの宣言せんげんのとき型かたが省略しょうりゃくされると、初期しょき値ちから型かたをコンパイラーが決きめてくれます（型かた推論すいろん）。 

const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const i = 0;
    try stdout.print("i = {}\n", .{i}); 
}
実行じっこう結果けっか
i = 0

このコードは、const キーワードを使つかって定数ていすうを宣言せんげんし、その値ねを出力しゅつりょくしています。

以下いかに、このコードの各かく部分ぶぶんの解説かいせつを示しめします。

  • const std = @import("std");：std という名前なまえで標準ひょうじゅんライブラリをインポートします。これにより、標準ひょうじゅんライブラリの機能きのうを使つかうことができます。
  • const stdout = std.io.getStdOut().writer();：標準ひょうじゅん出力しゅつりょくを表あらわす stdout という名前なまえのライターを取得しゅとくします。これにより、プログラムは標準ひょうじゅん出力しゅつりょくにテキストを書かき込こむことができます。
  • pub fn main() !void {：プログラムのエントリーポイントである main 関数かんすうを宣言せんげんします。この関数かんすうは、戻もどり値ちとしてエラーを返かえす可能かのう性せいがあるため、!void 型かたを返かえします。pub キーワードは、この関数かんすうが外部がいぶからアクセス可能かのうであることを示しめします。
  • const i = 0;：i という名前なまえの定数ていすうを宣言せんげんし、初期しょき値ちとして整数せいすう 0 を与あたえます。この定数ていすうは後あとで使用しようされます。
  • try stdout.print("i = {}\n", .{i});：標準ひょうじゅん出力しゅつりょくに文字もじ列れつを書かき込こむために print メソッドを使用しようします。"i = {}\n" の部分ぶぶんはフォーマット文字もじ列れつであり、{} の位置いちに i の値ねが挿入そうにゅうされます。.{i} は、変数へんすう i の値ねを挿入そうにゅうするための特別とくべつな構文こうぶんです。

var 変数へんすう

[編集へんしゅう]

キーワード var で変数へんすうを宣言せんげんするときも初期しょき化かは必須ひっすです。またいつでも値ねを変更へんこうすることはできます。 var 変数へんすうの宣言せんげんでは、型かたを省略しょうりゃくすることはできません。 

const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var i : isize = 0;
    try stdout.print("i = {}\n", .{i});
    i = 12;
    try stdout.print("i = {}\n", .{i});
    i *= i;
    try stdout.print("i = {}\n", .{i}); 
}
実行じっこう結果けっか
i = 0
i = 12
i = 144

このコードは、var キーワードを使用しようして可変かへんの変数へんすうを宣言せんげんし、その値ねを変更へんこうしています。

以下いかに、このコードの各かく部分ぶぶんの解説かいせつを示しめします。

  • const std = @import("std");：標準ひょうじゅんライブラリを std としてインポートします。
  • const stdout = std.io.getStdOut().writer();：標準ひょうじゅん出力しゅつりょくを表あらわす stdout という名前なまえのライターを取得しゅとくします。
  • pub fn main() !void {：プログラムのエントリーポイントである main 関数かんすうを宣言せんげんします。この関数かんすうは、エラーを返かえす可能かのう性せいがあるため、!void 型かたを返かえします。
  • var i : isize = 0;：i という名前なまえの変数へんすうを宣言せんげんし、型かたとして isize を指定していして初期しょき値ちとして整数せいすう 0 を与あたえます。
  • try stdout.print("i = {}\n", .{i});：標準ひょうじゅん出力しゅつりょくに文字もじ列れつを書かき込こむために print メソッドを使用しようします。"i = {}\n" の部分ぶぶんはフォーマット文字もじ列れつであり、{} の位置いちに i の値ねが挿入そうにゅうされます。
  • i = 12;：変数へんすう i の値ねを 12 に変更へんこうします。
  • try stdout.print("i = {}\n", .{i});：print メソッドを使用しようして、変更へんこう後ごの i の値ねを標準ひょうじゅん出力しゅつりょくに出力しゅつりょくします。
  • i *= i;：変数へんすう i の値ねを自乗じじょうして再さい代入だいにゅうします。
  • try stdout.print("i = {}\n", .{i});：print メソッドを使用しようして、再さい代入だいにゅう後ごの i の値ねを標準ひょうじゅん出力しゅつりょくに出力しゅつりょくします。

変数へんすうのシャドーイングは禁止きんし

[編集へんしゅう]

変数へんすうは、外部がいぶスコープの変数へんすうをシャドーイングすることは許ゆるされません[26]。

外部がいぶスコープの識別子しきべつしをシャドーイングすることは許ゆるされません
const x = 0;
pub fn main() !void {
    var x : isize = 1;
}
コンパイル結果けっか
main.zig:3:9: error: local variable shadows declaration of 'x' 
main.zig:1:1: note: declared here
 (exit status 1)

エラーメッセージによれば、外部がいぶスコープで宣言せんげんされた x がローカルスコープで再度さいど宣言せんげんされたため、エラーが発生はっせいしたことがわかります。Zigでは、外部がいぶスコープの変数へんすうをシャドーイングすることは許ゆるされていないため、このコードはコンパイルエラーとなります。

識別子しきべつし

[編集へんしゅう]

識別子しきべつしは英数字えいすうじかアンダースコアで始はじまり、英数字えいすうじかアンダースコアがいくつでも続つづくことができます[26]。また、キーワードと重かさなってはいけません[26]。

「#キーワード一覧いちらん」も参照さんしょう

外部がいぶライブラリーとのリンクなど、これらの要件ようけんに適合てきごうしない名前なまえが必要ひつような場合ばあいは、@""構文こうぶんを使用しようすることができます。 

const @"identifier with spaces in it" = 0xff;
const @"1SmallStep4Man" = 112358;
const c = @import("std").c;
pub extern "c" fn @"error"() void;
pub extern "c" fn @"fstat$INODE64"(fd: c.fd_t, buf: *c.Stat) c_int;
const Color = enum {
    red,
    @"really red",
};
const color: Color = .@"really red";

このコードは、Zigで識別子しきべつしにスペースが含ふくまれる場合ばあいや、数字すうじで始はじまる識別子しきべつしを使用しようする方法ほうほう、および外部がいぶC関数かんすうに識別子しきべつしを付つける方法ほうほうを示しめしています。

以下いかに、各かく部分ぶぶんの解説かいせつを示しめします。

  1. const @"identifier with spaces in it" = 0xff;：スペースが含ふくまれる識別子しきべつしを使用しようして、定数ていすうを宣言せんげんしています。Zigでは、ダブルクォートで囲かこまれた文字もじ列れつを識別子しきべつしとして使用しようすることができます。
  2. const @"1SmallStep4Man" = 112358;：数字すうじで始はじまる識別子しきべつしを使用しようして、定数ていすうを宣言せんげんしています。同様どうように、ダブルクォートで囲かこまれた文字もじ列れつを識別子しきべつしとして使用しようしています。
  3. const c = @import("std").c;：外部がいぶライブラリをインポートして、その一部いちぶを c という名前なまえで定数ていすうとして使用しようします。これにより、外部がいぶのCライブラリで定義ていぎされた型かたや関数かんすうにアクセスすることができます。
  4. pub extern "c" fn @"error"() void;：外部がいぶC関数かんすうに識別子しきべつしを付つけて宣言せんげんしています。extern "c" はC言語げんごの呼よび出だし規約きやくを指定していし、void は戻もどり値ちの型かたを示しめしています。
  5. pub extern "c" fn @"fstat$INODE64"(fd: c.fd_t, buf: *c.Stat) c_int;：同様どうように、外部がいぶC関数かんすうに識別子しきべつしを付つけて宣言せんげんしています。この関数かんすうは引数ひきすうを取とり、c_int 型かたを戻もどり値ちとして返かえします。
  6. const Color = enum { red, @"really red", };：列挙れっきょ型がた Color を定義ていぎしています。@"really red" のように、列挙れっきょ子こにも識別子しきべつしを付つけることができます。
  7. const color: Color = .@"really red";：Color 列挙れっきょ型がたの変数へんすう color を宣言せんげんし、@"really red" の列挙れっきょ子こを初期しょき値ちとして指定していしています。

このように、Zigでは識別子しきべつしにスペースや数字すうじを含ふくめることができ、また識別子しきべつしを外部がいぶC関数かんすうに付つけることもできます。これにより、異ことなる名前なまえ付づけ規則きそくを持もつライブラリや関数かんすうをZigのコードから使用しようすることができます。

https://ziglang.org/documentation/master/#Identifiers から引用いんよう

整数せいすう

[編集へんしゅう]

整数せいすうリテラル

[編集へんしゅう]

Zigでは、さまざまな整数せいすうリテラルの表現ひょうげんがサポートされています。

  • 10進数しんすう：const decimal_int = 98222;
  • 16進数しんすう：const hex_int = 0xff;
  • 8進数しんすう：const octal_int = 0o755;
  • 2進数しんすう：const binary_int = 0b11110000;
  • アンダースコアを使用しようした視覚しかく的てきな区切くぎり：const one_billion = 1_000_000_000;
構文こうぶん(EBNF)
INTEGER = "0b" bin_int skip
        | "0o" oct_int skip
        | "0x" hex_int skip
        |      dec_int skip

skip = ([ \n] | line_comment)*

bin = "0" | "1"
bin_ = [ '_' ] bin
oct = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7"
oct_ = [ '_' ] oct
hex = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
    | "a" | "b" | "c" | "d" | "e" | "f"
    | "A" | "B" | "C" | "D" | "E" | "F"
hex_ = [ '_' ] hex
dec =  "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
dec_ = [ '_' ] dec
bin_int = bin bin_*
oct_int = oct oct_*
dec_int = dec dec_*
hex_int = hex hex_*
[21]。
2進数しんすう・8進数しんすう・16進数しんすうはそれぞれ 0b・0o・0x を前まえ置おけします。
他たの多おおくの言語げんごと異ことなり 0 の次つぎの文字もじは小文字こもじが必須ひっすで、大文字おおもじは受うけ付つけません。

実行じっこう時じの整数せいすう値ち

[編集へんしゅう]

整数せいすうリテラルにはサイズ制限せいげんがなく、不明ふめいな動作どうさが発生はっせいする場合ばあいにはコンパイラがそれをキャッチします。

ただし、整数せいすう値ちがコンパイル時じには不明ふめいである場合ばあい、サイズが判明はんめいしている必要ひつようがあり、未定義みていぎの動作どうさの影響えいきょうを受うけます。 

fn divide(a: i32, b: i32) i32 {
    return a / b;
}

このような関数かんすうでは、値ね a と b は実行じっこう時じのみに判明はんめいするため、この除算じょざん操作そうさは整数せいすうオーバーフローやゼロ除算じょざんの影響えいきょうを受うける可能かのう性せいがあります。

演算えんざん子こ

[編集へんしゅう]

整数せいすう演算えんざんでは、+ や - などの演算えんざん子こは整数せいすうオーバーフローに対たいして未み定義ていぎの動作どうさを引ひき起おこします。代かわりに、すべてのターゲットに対たいしてラッピングおよびサチュレーティング演算えんざんを行おこなうための代替だいたい演算えんざん子こが提供ていきょうされています。

  • ラッピング演算えんざん子こ：+% および -%
  • サチュレーティング演算えんざん子こ：+| および -|

Zigでは任意にんいのビット幅はばの整数せいすうもサポートされており、i または u の後のちに数字すうじが続つづく識別子しきべつしを使用しようして参照さんしょうされます。たとえば、i7 は7ビットの符号ふごう付つき整数せいすうを示しめします。符号ふごう付つき整数せいすう型がたの場合ばあい、Zigでは2の補数ほすう表現ひょうげんが使用しようされます。

ラッピング演算えんざんおよびサチュレーティング演算えんざんとオーバーフローの例れい
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var i: i5 = 0;
    var j: i4 = 0;
    var k: i4 = 0;

    while (i < 20) {
        try stdout.print("i:{}, j:{}, k:{}\n", .{ i, j, k });
        i = i + 1;
        j = j +% 1;
        k = k +| 1;
    }
}
実行じっこう結果けっか
i:0, j:0, k:0
i:1, j:1, k:1
i:2, j:2, k:2
i:3, j:3, k:3
i:4, j:4, k:4
i:5, j:5, k:5
i:6, j:6, k:6
i:7, j:7, k:7
i:8, j:-8, k:7
i:9, j:-7, k:7
i:10, j:-6, k:7
i:11, j:-5, k:7
i:12, j:-4, k:7
i:13, j:-3, k:7
i:14, j:-2, k:7
i:15, j:-1, k:7
thread 1 panic: integer overflow
/sandbox/src/main.zig:11:15: 0x21e650 in main (main)
        i = i + 1;
              ^
/usr/lib/zig/std/start.zig:574:37: 0x21e4fe in posixCallMainAndExit (main)
            const result = root.main() catch |err| {
                                    ^
/usr/lib/zig/std/start.zig:243:5: 0x21dfe1 in _start (main)
    asm volatile (switch (native_arch) {
    ^
???:?:?: 0x0 in ??? (???)
 (exit status 139)

このZigのプログラムは、異ことなるビット幅はばの整数せいすう型がたを使用しようし、それらの振ふる舞まいを示しめしています。以下いかにコードの解説かいせつを示しめします。

  • var i: i5 = 0;：i という名前なまえの変数へんすうを宣言せんげんし、初期しょき値ちとして 0 を与あたえます。この変数へんすうは i5 型かたであり、5ビットの符号ふごう付つき整数せいすうを表あらわします。
  • var j: i4 = 0;：j という名前なまえの変数へんすうを宣言せんげんし、初期しょき値ちとして 0 を与あたえます。この変数へんすうは i4 型かたであり、4ビットの符号ふごう付つき整数せいすうを表あらわします。
  • var k: i4 = 0;：k という名前なまえの変数へんすうを宣言せんげんし、初期しょき値ちとして 0 を与あたえます。この変数へんすうも i4 型かたであり、4ビットの符号ふごう付つき整数せいすうを表あらわします。
  • while (i < 20) { ... }：i の値ねが20未満みまんの間あいだ、ループが続つづきます。
  • i = i + 1;：変数へんすう i の値ねを1増加ぞうかさせます。この演算えんざんは、i5 型かたの整数せいすうの範囲はんいを超こえる可能かのう性せいがあり、後のちに整数せいすうオーバーフローが発生はっせいします。
  • j = j +% 1;：変数へんすう j の値ねを1増加ぞうかさせます。ここではラップアラウンド演算えんざん子こ +% を使用しようしています。これにより、j の値ねが範囲はんい外がいになる場合ばあいは0に戻もどります。
  • k = k +| 1;：変数へんすう k の値ねを1増加ぞうかさせます。ここでは飽和ほうわ演算えんざん子こ +| を使用しようしています。これにより、k の値ねが範囲はんい外がいになる場合ばあいは最大さいだい値ちに飽和ほうわします。

プログラムの実行じっこう結果けっかから、i の値ねがオーバーフローし、未定義みていぎの振ふる舞まいが発生はっせいしました。これは i5 型かたの整数せいすうが範囲はんいを超こえたためです。このような場合ばあい、Zigは整数せいすうオーバーフローを検出けんしゅつしてプログラムをパニックさせます。一方いっぽうで、j の値ねはラッピング演算えんざん子こにより範囲はんい外がいになることなく、k の値ねは飽和ほうわ演算えんざん子こにより最大さいだい値ちで飽和ほうわしています。

浮動ふどう小数点しょうすうてん数すう

[編集へんしゅう]

浮動ふどう小数点しょうすうてん数すうの種類しゅるい

[編集へんしゅう]

Zigでは、以下いかの浮動ふどう小数点しょうすうてん数すう型がたがサポートされています：

  • f16：IEEE-754-2008バイナリ16
  • f32：IEEE-754-2008バイナリ32
  • f64：IEEE-754-2008バイナリ64
  • f80：IEEE-754-2008 80ビット拡張かくちょう精度せいど
  • f128：IEEE-754-2008バイナリ128
  • c_longdouble：対象たいしょうC ABIのlong doubleに対応たいおう

浮動ふどう小数点しょうすうてん数すうリテラル

[編集へんしゅう]

浮動ふどう小数点しょうすうてん数すうリテラルは、comptime_float型がたを持もち、最大さいだいの他ほかの浮動ふどう小数点しょうすうてん数すう型がた（f128）と同おなじ精度せいどと操作そうさを保証ほしょうします。

浮動ふどう小数点しょうすうてん数すうリテラルは、任意にんいの浮動ふどう小数点しょうすうてん数すう型がたおよび整数せいすう型がた（小数点しょうすうてん以下いかがない場合ばあい）に変換へんかんされます。 

const floating_point = 123.0E+77;
const another_float = 123.0;
const yet_another = 123.0e+77;

const hex_floating_point = 0x103.70p-5;
const another_hex_float = 0x103.70;
const yet_another_hex_float = 0x103.70P-5;
構文こうぶん(EBNF)
FLOAT = "0x" hex_int "." hex_int [ ( "p" | "P" ) [ "-" | "+" ] dec_int ] skip
      |      dec_int "." dec_int [ ( "e" | "E" ) [ "-" | "+" ] dec_int ] skip
      | "0x" hex_int ( "p" | "P" ) [ "-" | "+" ] dec_int skip
      |      dec_int ( "e" | "E" ) [ "-" | "+" ] dec_int skip
[21]。
10進数しんすうのほか、16進数しんすうの浮動ふどう小数点しょうすうてん数すうリテラルに対応たいおうしていますが、2進数しんすう・8進数しんすうの浮動ふどう小数点しょうすうてん数すうリテラルには対応たいおうしていません。
16進数しんすうの浮動ふどう小数点しょうすうてん数すうリテラルも、指数しすう部ぶは10進数しんすうです。

特殊とくしゅな浮動ふどう小数点しょうすうてん数値すうち

[編集へんしゅう]

NaN、無限むげん大だい、負まけの無限むげん大だいのための構文こうぶんはありません。これらの特殊とくしゅな値ねについては、標準ひょうじゅんライブラリを使用しようする必要ひつようがあります。 

const std = @import("std");

const inf = std.math.inf(f32);
const negative_inf = -std.math.inf(f64);
const nan = std.math.nan(f128);

浮動ふどう小数点しょうすうてん数すうの演算えんざん

[編集へんしゅう]

デフォルトでは、浮動ふどう小数点しょうすうてん数すうの演算えんざんはStrictモードを使用しようしますが、ブロックごとにOptimizedモードに切きり替かえることができます。 

export fn foo_strict(x: f64) f64 {
    return x + big - big;
}

export fn foo_optimized(x: f64) f64 {
    @setFloatMode(.Optimized);
    return x + big - big;
}

上記じょうきの例れいでは、演算えんざんをStrictモードとOptimizedモードで比較ひかくしています。

演算えんざん子こ

[編集へんしゅう]

Zigの演算えんざん子この概要がいようは以下いかの通とおりです：

加算かさんと減算げんざん

[編集へんしゅう]
  • 加算かさん：a + b、a += b
  • 減算げんざん：a - b、a -= b
  • ラップ加算かさん：a +% b、a +%= b
  • ラップ減算げんざん：a -% b、a -%= b
  • 飽和ほうわ加算かさん：a +| b、a +|= b
  • 飽和ほうわ減算げんざん：a -| b、a -|= b

乗算じょうざんと除算じょざん

[編集へんしゅう]
  • 乗算じょうざん：a * b、a *= b
  • 除算じょざん：a / b、a /= b
  • ラップ乗算じょうざん：a *% b、a *%= b
  • 飽和ほうわ乗算じょうざん：a *| b、a *|= b
  • 剰余じょうよ除算じょざん：a % b、a %= b

ビット演算えんざん

[編集へんしゅう]
  • ビットシフト：左ひだりシフト a << b、右みぎシフト a >> b
  • ビット AND：a & b、a &= b
  • ビット OR：a | b、a |= b
  • ビット XOR：a ^ b、a ^= b
  • ビット NOT：~a

論理ろんり演算えんざん

[編集へんしゅう]
  • 論理ろんり AND：a and b
  • 論理ろんり OR：a or b
  • 論理ろんり NOT：!a

比較ひかく演算えんざん子こ

[編集へんしゅう]
  • 等ひとしい：a == b
  • 等ひとしくない：a != b
  • 大だいなり：a > b
  • 大だいなりイコール：a >= b
  • 小しょうなり：a < b
  • 小しょうなりイコール：a <= b

オプショナルとエラー処理しょり

[編集へんしゅう]
  • オプショナルのデフォルト値ち取得しゅとく：a orelse b
  • オプショナルのアンラップ：a.?
  • エラー処理しょりのデフォルト値ち取得しゅとく：a catch b、a catch |err| b

その他た

[編集へんしゅう]
  • アドレス取得しゅとく：&a
  • ポインタの参照さんしょう：a.*

演算えんざん子この詳細しょうさいは、Zigのドキュメントやリファレンスを参照さんしょうしてください。

制御せいぎょ構造こうぞう

[編集へんしゅう]

Zigは、やや関数かんすう型がたプログラミング言語げんごの影響えいきょうを受うけており、多おおくの構文こうぶんが値ねを持もちます。 Zigの制御せいぎょ構造こうぞうの多おおくは式しき構文こうぶんと文ぶん構文こうぶんを持もちます（例外れいがいは #switch で式しき構文こうぶんしかありません）。

以下いか、Kotlin#分岐ぶんきから、一部いちぶの例れいを移植いしょくしました。

分岐ぶんき

[編集へんしゅう]

Zigには、#if と #switch の２ふたつの分岐ぶんき構文こうぶんがあります。

if
[編集へんしゅう]

Zigでは、if は値ねを分岐ぶんきする if式しき とブロックを分岐ぶんきする if文ぶん があります。

構文こうぶん(EBNF)[21]
if-expr = if-prefix expr [ "else" [ payload ] expr ]
if-prefix = "if" "(" expr ")" [ ptr-payload ]
payload = "|" IDENTIFIER "|"
ptr-payload = "|" [ "*" ] IDENTIFIER "|"

if-statement = if-prefix block-expr [ "else" [ payload ] statement ]
             | if-prefix assign-expr ( ”;” | "else" [ payload ] statement )
block-expr = [ block-label ] block
block-label = IDENTIFIER ":"
block = "{" statement* "}"
assign-expr = expr [ assign-op expr ]
assign-op = "+=" | "-=" | "*=" | "/=" ...（略りゃく）
if式しきの例れい
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const i = 0;

    if (i == 0)
        try stdout.writeAll("zero\n") // ここに ; があるとエラーになります。
    else
        try stdout.writeAll("non zero\n");

    try stdout.print(if (i == 0)
        "ゼロ\n"
    else
        "非ひゼロ\n", .{});
}
実行じっこう結果けっか
zero 
ゼロ
8行ぎょう目めに ; があると if 式しきがそこで終おわってしまい、else と結合けつごうできません。ブロックを使つかえば…
if文ぶんに変更へんこう
    if (i == 0) {
        try stdout.writeAll("zero\n"); // ブロック中ちゅうならば ; があってもエラーになりません。
    } else {
        try stdout.writeAll("non zero\n");
    }
と ; を使つかうことができます[27]。
条件じょうけん不成立ふせいりつでelseを省略しょうりゃくすると
[編集へんしゅう]

if式しきで、条件じょうけんが成立せいりつせずelseを省略しょうりゃくされたとき、式しきの値ねは void となります。

条件じょうけん不成立ふせいりつでelseを省略しょうりゃくすると
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    try stdout.print("if (false) 1 => {}\n", .{ if (false) 1 });
}
実行じっこう結果けっか
if (false) 1 => void
条件じょうけん式しきに整数せいすうを使つかうと
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const i = 0;

    if (i) {
        try stdout.writeAll("not zero");
    }
}
コンパイルエラー
./main.zig:7:9: error: expected type 'bool', found 'comptime_int'
    if (i) { 
        ^
Zigでは、if に限かぎらず、条件じょうけん式しきは、bool、オプショナル型がたあるいはエラーユニオン型がたでなければいけません。
    if (i != 0) {
とします。
オプショナル型がたを条件じょうけんとしたif
[編集へんしゅう]

ifの条件じょうけん式しきにはオプショナル型がた( ?T )を使つかうことが出来できます。この場合ばあいは、通常つうじょうの値ねのほか null を想定そうていでき、null に出会であった場合ばあいは else 節ぶしが実行じっこうされます。

「オプショナル型がたを条件じょうけんとしたwhile」も参照さんしょう
nullable-if.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var a: ?u16 = 42;
    if (a) |*value| {
        try stdout.print("value.* = {}({})\n", .{value.*, @TypeOf(value.*)});
        value.* = 123;
    } else {
        unreachable;
    }
    if (a) |n| {
        try stdout.print("n = {}({})\n", .{n, @TypeOf(n)});
    } else {
        unreachable;
    }
    a = null;
    if (a) |_| {
        unreachable;
    } else {
        try stdout.print("a = {?}({})\n", .{a, @TypeOf(a)});
    }
}
実行じっこう結果けっか
value.* = 42(u16)
n = 123(u16)
a = null(?u16)

このコードでは、aという名前なまえのオプショナル型がたの変数へんすうを定義ていぎし、最初さいしょに値ね 42 で初期しょき化かしています。

次つぎに、最初さいしょのif文ぶんでは、aがnullでない場合ばあいにブロック内ないの処理しょりが実行じっこうされます。この場合ばあい、|*value|構文こうぶんを使つかってオプショナル型がたの値ねを取とり出だし、そのポインターをvalueに割わり当あてています。その後ご、取とり出だした値ねを出力しゅつりょくしてから、その値ねを123に書かき換かえています。

2番目ばんめのif文ぶんも同様どうように、aがnullでない場合ばあいにブロック内ないの処理しょりが実行じっこうされます。ただし、こちらでは|n|の構文こうぶんを使つかってオプショナル型がたの値ねそのものを取とり出だし、その値ねを出力しゅつりょくしています。

最後さいごのif文ぶんでは、aにnullを割わり当あてています。その後ご、aがnullであるかどうかをチェックし、nullの場合ばあいにはelseブロック内ないの処理しょりが実行じっこうされます。ここでは、|_|の構文こうぶんを使つかって、取とり出だす値ねがないことを示しめしています。その後ご、aがnullであることを出力しゅつりょくしています。

実行じっこう結果けっかを見みると、それぞれのif文ぶんが条件じょうけんに応おうじて正まさしく動作どうさしていることがわかります。

エラーユニオン型がたを条件じょうけんとしたif
[編集へんしゅう]

ifの条件じょうけん式しきにはエラーユニオン型がた( !T )を使つかうことが出来できます。この場合ばあいは、通常つうじょうの値ねのほかエラーコードを想定そうていでき、エラーコードに出会であった場合ばあいは else |err| 節ふしが実行じっこうされ、err がエラーコードです。

「エラーユニオン型がたを条件じょうけんとしたwhile」も参照さんしょう
errorunion-if.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {    
    var b: anyerror!u32 = error.BadValue;
    try stdout.print("b = {any}({})\n", .{b, @TypeOf(b)});
    if (b) |_| {
        unreachable;
    } else |err| {
        try stdout.print("err = {?}({})\n", .{err, @TypeOf(err)});
    }
    b = 4423;
    try stdout.print("b = {any}({})\n", .{b, @TypeOf(b)});
    if (b) |n| {
        try stdout.print("n = {}({})\n", .{n, @TypeOf(n)});
    } else |_| {
        unreachable;
    }
}
実行じっこう結果けっか
b = error.BadValue(anyerror!u32)
err = error.BadValue(anyerror)
b = 4423(anyerror!u32)
n = 4423(u32)

このコードでは、bという名前なまえのエラーユニオン型がたの変数へんすうを定義ていぎし、最初さいしょにerror.BadValueというエラーコードを割わり当あてます。

次つぎに、最初さいしょのif文ぶんでは、bがエラーコードを持もっている場合ばあいにはelse |err|ブロック内ないの処理しょりが実行じっこうされます。この場合ばあい、|err|の構文こうぶんを使つかってエラーコードを取とり出だし、そのエラーコードをデバッグ出力しゅつりょくしています。

2番目ばんめのif文ぶんも同様どうように、bがエラーコードを持もっている場合ばあいにはelse |_|ブロック内ないの処理しょりが実行じっこうされます。ただし、こちらでは|n|の構文こうぶんを使つかってエラーコードの値ねそのものを取とり出だし、その値ねをデバッグ出力しゅつりょくしています。

実行じっこう結果けっかを見みると、それぞれのif文ぶんが条件じょうけんに応おうじて正まさしく動作どうさしていることがわかります。最初さいしょの場合ばあいではエラーコードが出力しゅつりょくされ、2番目ばんめの場合ばあいでは正常せいじょうな値ねが出力しゅつりょくされています。

switch
[編集へんしゅう]

Zigでは、switch は式しきで値ねを返かえします。switch文ぶんはありません。switch-prong（分岐ぶんき先さき）の値ねの型かたは一致いっちしている必要ひつようがあります。

構文こうぶん(EBNF)
switch-expr = "switch" "(" expr ")" "{" switch-prong-list "}"
switch-prong-list = (switch-prong "," )* [ switch-prong ]
switch-prong = switch-case "=>" [ ptr-payload ] assign-expr
switch-case = switch-item ( "," switch-item )* [ "," ] | "else"
switch-item = expr [ "..." expr ]
[21]
switch.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const ary = .{1, 'Z', 3.14, .{1,2,3}, true, void, null, i64};
    inline for (ary) |obj| {
        switch (@typeInfo(@TypeOf(obj))) {
            .ComptimeInt => try stdout.print("ComptimeInt: {}\n", .{obj}),
            .ComptimeFloat => try stdout.print("ComptimeFloat: {}\n", .{obj}),
            .Struct => try stdout.print("Struct: {}\n", .{obj}),
            .Bool => try stdout.print("Bool: {}\n", .{obj}),
            .Type => try stdout.print("Type: {}\n", .{obj}),
            .Null => try stdout.print("Null: {}\n", .{obj}),
            else => try stdout.print("{}\n", .{@typeInfo(@TypeOf(obj))})
        }
    } 
}
実行じっこう結果けっか
ComptimeInt: 1
ComptimeInt: 90
ComptimeFloat: 3.14e+00
Struct: { 1, 2, 3 }
Bool: true
Type: void
Null: null 
Type: i64

反復はんぷく

[編集へんしゅう]

Zigには、#while と #for の２ふたつの反復はんぷく構文こうぶんがあります。

while
[編集へんしゅう]

whileは条件じょうけんが成立せいりつしている間あいだ、繰くり返かえしを行おこないます。条件じょうけんがブロック内ないで評価ひょうかされ、条件じょうけんが偽にせになるまで続つづきます。whileにはelse節ふしもあり、ループ完了かんりょう後ごに実行じっこうされます。また、ラベルを付つけてネストしたループからのbreakやcontinueも可能かのうです。オプショナル型がたやエラーユニオン型がたの条件じょうけんも受うけ付つけ、それらの値ねをキャプチャできます。インライン化かも可能かのうで、コンパイル時じの最適さいてき化かや型かたの利用りようが可能かのうです。

構文こうぶん(EBNF)
loop-expr = [ "inline" ] ( for-expr | while-expr )
while-expr = while-prefix expr [ "else" [ payload ] expr ]
while-prefix = "while" "(" expr ")" [ ptr-payload ] [ while-continue-expr ]
while-continue-expr = ":" "(" assign-expr ")"

while-statement = while-prefix block-expr [ "else" [ pay-load ] statement ]
                | while-prefix assign-expr ( ”;” | "else" [ payload ] statement )
多おおくの構文こうぶん要素ようそは if と共通きょうつうしているので #if の構文こうぶんも参照さんしょうしてください[21]。
Zigも、pythonのように else を伴ともなうことのできる while です。
whileの例れい
[編集へんしゅう]
while.zig
pub fn main() !void {
    var i: usize = 1;
    while (i < 50) : (i += 1) {
        try stdout.print("{}! == {}\n", .{ i, fib(i) });
    }
}

fn fib(n: usize) usize {
    return if (n < 2) n else fib(n - 1) + fib(n - 2);
}

const stdout = std.io.getStdOut().writer();
const std = @import("std");
実行じっこう結果けっか
An error occurred:
1! == 1
2! == 1
3! == 2
4! == 3
5! == 5
6! == 8
7! == 13
8! == 21
9! == 34
10! == 55
11! == 89
12! == 144
13! == 233
14! == 377
15! == 610
16! == 987
17! == 1597
18! == 2584
19! == 4181
20! == 6765
21! == 10946
22! == 17711
23! == 28657
24! == 46368
25! == 75025
26! == 121393
27! == 196418
28! == 317811
29! == 514229
30! == 832040
31! == 1346269
32! == 2178309
33! == 3524578
34! == 5702887
35! == 9227465
36! == 14930352
37! == 24157817
38! == 39088169
39! == 63245986

    while (i < 50) : (i += 1) {
        try stdout.print("{}! == {}\n", .{ i, fib(i) });
    }
は
    while (i < 50) {
        try stdout.print("{}! == {}\n", .{ i, fib(i) });
        i += 1;
    }
と等価とうかで、追加ついかの式しきはC言語げんごの for (;;) の三さん項目こうもくにあたります。
elseを伴ともなったwhileの例れい
[編集へんしゅう]
while-with-else.zig
const stdout = std.io.getStdOut().writer();
const std = @import("std");

pub fn main() !void {
    var i: usize = 0;
    while (i < 5) : (i += 1) {
        try stdout.print("{} ", .{i});
    } else {
        try stdout.writeAll("done!\n");
    }
    i = 0;
    while (i < 50) : (i += 1) {
        try stdout.print("{} ", .{i});
        if (i == 10) {
            try stdout.writeAll("break!\n");
            break;
        }
    } else {
        try stdout.writeAll("done!\n");
    }
}
実行じっこう結果けっか
0 1 2 3 4 done!
0 1 2 3 4 5 6 7 8 9 10 break!
while のループを「完走かんそう」すると、else 以降いこうが実行じっこうされます。
もし break などで中断ちゅうだんされると、else 以降いこうは実行じっこうされません。
elseを伴ともなったwhileの使つかいどころ
Zigのwhileループは完走かんそうすると実行じっこうするelse節ぶしを置おくことができます。

では、このelse節ぶしは何なにに使つかうのでしょう？

1000以下いかの素数そすうを求もとめる（フラッグ版ばん）
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var i: usize = 2;
    while (i <= 1000) : (i += 1) {
        var j: usize = 2;
        var is_prime = true;
        while (j * j <= i) : (j += 1) {
            if (i % j == 0) {
                is_prime = false;
                break;
            }
        }
        if (is_prime)
            try stdout.print("{} ", .{i});
    }
}
break で抜ぬけたかをフラッグ is_prime で判断はんだんしていますが、
1000以下いかの素数そすうを求もとめる（else版ばん）
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var i: usize = 2;
    while (i <= 1000) : (i += 1) {
        var j: usize = 2;
        while (j * j <= i) : (j += 1) {
            if (i % j == 0) {
                break;
            }
        } else try stdout.print("{} ", .{i});
    }
}
フラッグがなくなり簡素かんそになりました。
Zig以外いがいの言語げんごでは、Pythonでも else を伴ともなったループ構文こうぶんがあります。
ラベル付つきwhile
[編集へんしゅう]

whileループにラベルを付つけると、ネストしたループ内ないからのbreakやcontinueから参照さんしょうできます[28]。

ラベル付つきwhile
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var i: u16 = 0;
    var j: u16 = 0;
    outer: while (i < 15) : (i += 1) {
       j = 0;
        while (j < 15) : (j += 1) {
            if (i == 7 and j == 11) {
                break :outer;
            }
        }
    }
    try stdout.print("i = {}, j = {}\n", .{ i, j });
}
実行じっこう結果けっか
i = 7, j = 11
オプショナル型がたを条件じょうけんとしたwhile
[編集へんしゅう]

ifと同おなじように、whileループは条件じょうけんとしてオプショナル型がたの値ねを受うけ取とり、ペイロードをキャプチャすることができます。null に遭遇そうぐうした場合ばあい、ループは終了しゅうりょうします[29]。

while 式しきに |x| 構文こうぶんがある場合ばあい、while 条件じょうけんはオプショナル型がた（あるいは次つぎで述のべるエラーユニオン型がた）でなければなりません（この x かキャプチャされたペイロードです）。

オプショナル型がたを条件じょうけんとしたwhile
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var sum: u32 = 0;
    while (sequence()) |n| {
        sum += n;
    }
    try stdout.print("sum = {}\n", .{sum});
}

fn sequence() ?u32 {
    const S = struct {
        var x: u32 = 5;
    };
    return if (S.x == 0) null else blk: {
        S.x -= 1;
        break :blk S.x;
    };
}
実行じっこう結果けっか
sum = 10
エラーユニオン型がたを条件じょうけんとしたwhile
[編集へんしゅう]

ifと同おなじように、whileループは条件じょうけんとしてエラーユニオン型がたの値ねを受うけ取とり、ペイロードをキャプチャすることができます。エラーコードに遭遇そうぐうした場合ばあい、ループは終了しゅうりょうします[30]。

while 式しきに |x| 構文こうぶんがある場合ばあい、while 条件じょうけんはエラーユニオン型がた（あるいは前まえで述のべたオプショナル型がた）でなければなりません（この x かキャプチャされたペイロードです）。

while 式しきに else |x| 構文こうぶんがある場合ばあい、while 条件じょうけんにエラーユニオン型がたが必要ひつようです。

エラーユニオン型がたを条件じょうけんとしたwhile
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var sum: u32 = 0;
    while (sequence()) |n| {
        sum += n;
    } else |err| {
        try stdout.print("err = {}\n", .{err});
    }
    try stdout.print("sum = {}\n", .{sum});
}

fn sequence() !u32 {
    const S = struct {
        var x: u32 = 5;
    };
    return if (S.x == 0) error.ReachedZero else blk: {
        S.x -= 1;
        break :blk S.x;
    };
}
実行じっこう結果けっか
err = error.ReachedZero 
sum = 10
inline while
[編集へんしゅう]

whileループはインライン化かすることができる。これにより、ループが展開てんかいされ、コンパイル時じにしかできないこと、例たとえば、型かたをファーストクラスの値ねとして使用しようすることなどができるようになります[31]。

「inline for」も参照さんしょう

[TODO:コード例れい]

for
[編集へんしゅう]

Zigのforループは、スライスや配列はいれつをイテレートする際さいに柔軟じゅうなん性せいを提供ていきょうします。要素ようそごとに処理しょりを行おこない、continueやbreakを使用しようして制御せいぎょフローを操作そうさできます。インデックスや複数ふくすうのオブジェクトの同時どうじイテレーション、参照さんしょうによるイテレーションなど、多彩たさいな機能きのうを持もちます。また、forループを式しきとして使用しようすることも可能かのうで、else節ふしを使つかってループが完了かんりょうした際さいに特定とくていの処理しょりを行おこなうことができます。ラベル付つきループやインライン化かもサポートされ、効率こうりつ的てきなコーディングを実現じつげんします。

構文こうぶん(EBNF)
for-statement = "for" for-prefix block-expr [ "else" statement ]
for-expr = "for" for-prefix expr [ "else" expr ]
for-prefix = "(" for-arguments-list ")" ptr-list-payload
for-arguments-list = for-item { "," for-item } [ "," ]
for-item = expr [ ".." expr]
ptr-list-payload = "|" [ "*" ] IDENTIFIER { "," [ "*" ] IDENTIFIER } [ "," ] "|"
[21]。
for-ary.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const int = i16;
    const ary = [_]int{ 1, 5, 4, 6, 4, 9 };
    var sum: int = 0;

    for (ary, 0..) |n, i| {
        try stdout.print("n = {}, i = {}\n", .{ n, i });
        sum += n;
    }
    try stdout.print("sum = {}\n", .{sum});

    var ary2 = ary;

    for (&ary2) |*r| {
        r.* += 10;
    }
    for (ary2) |n| {
        try stdout.print("{}, ", .{n});
    }
}
実行じっこう結果けっか
n = 1, i = 0
n = 5, i = 1
n = 4, i = 2
n = 6, i = 3
n = 4, i = 4
n = 9, i = 5
sum = 29
11, 15, 14, 16, 14, 19,
for-str.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    const str = "simple string";

    for (str) |c| {
        try stdout.print("{c} ", .{c});
    }
}
実行じっこう結果けっか
s i m p l e   s t r i n g
for-range.zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    for (23..43) |i| {
        try stdout.print("{} ", .{i});
    }
}
実行じっこう結果けっか
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
ラベル付つきfor
[編集へんしゅう]

ラベル付つきfor( Labeled for )とは、ラベルを伴ともなった for ループでラベルも for 構文こうぶんの一部いちぶです。for ループにラベルを付つけると、ネストしたループ内ないからのbreakやcontinueから参照さんしょうできます[32]。

ラベル付つきfor
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var x: usize = undefined;
    var y: usize = undefined;

    loop_top: for ("Hello", 0..) |co, i| {
        for ("World", 0..) |ci, j| {
            if (co == ci) {
                try stdout.print("c = '{c}'({}, {})\n", .{ ci, i, j });
                x = i;
                y = j;
                break :loop_top;
            }
        }
    }
    try stdout.print("x = {}, y = {}\n", .{ x, y });
}
実行じっこう結果けっか
c = 'l'(2, 3) 
x = 2, y = 3
inline for
[編集へんしゅう]

Forループはインライン化かすることができます。これにより、ループが展開てんかいされ、コンパイル時じにしかできないこと、例たとえば、型かたをファーストクラスの値ねとして使用しようすることなどができるようになります。インライン化かされたforループのキャプチャ値ちとイテレータ値ちは、コンパイル時じ既知きちです[33]。

inline for
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var x: usize = undefined;
    var y: usize = undefined;

    loop_top: inline for ("Hello", 0..) |co, i| {
        inline for ("World", 0..) |ci, j| {
            if (co == ci) {
                try stdout.print("c = '{c}'({}, {})\n", .{ ci, i, j });
                x = i;
                y = j;
                break :loop_top;
            }
        }
    }
    try stdout.print("x = {}, y = {}\n", .{ x, y });
}
実行じっこう結果けっか
c = 'l'(2, 3) 
x = 2, y = 3

関数かんすう

[編集へんしゅう]

Zigの関数かんすうは、プログラム内ないで再さい利用りよう可能かのうなコードブロックを表あらわします。

Zigの関数かんすうの引数ひきすうは、const で宣言せんげんされた変数へんすうと同おなじくイミュータブルです。 ミュータブルにする方法ほうほうはありません。

構文こうぶん(EBNF)
top-level-decl = [ "inline" | "noinline" ] FnProto ( ";" | block )
FnProto = "fn" [ IDENTIFIER ] "(" param-decl-list ")" [ byte-align ] [ link-section ] [ call-conv ] [ "!" ] type-expr
param-decl-list = ( param-decl "," )* [ param-decl ]
param-decl = [ doc_comment ] [ "noalias" | "comptime" ] [ IDENTIFIER ":" ] param-type | "..."
param-type = "anytype" | type-expr
type-expr = [ prefix-type-op ] ErrorUnionExpr
prefix-type-op = "?"
             | "anyframe" "->"
             | slice-type-start ( byte-align | "const" | "volatile" | "allowzero" )*
             | ptr-type-start ( "align" "(" expr [ ":" INTEGER ":" INTEGER) ] ")"  | "const" | "volatile" | "allowzero" )*
             | array-type-start
slice-type-start = "[" [ ":" expr ] "]"
byte-align = "align" "(" expr ")"
link-section = "linksection" "(" expr ")"
call-conv = "callconv" "(" expr ")"
ptr-type-start = "*" | "**" | "[" "*" [ "c" | ":" expr ] "]"
array-type-start = "[" expr [ ":" expr ] "]"
top-level-declは関数かんすう宣言せんげんの他ほか、変数へんすう宣言せんげんなども含ふくみますが、関数かんすう宣言せんげん部分ぶぶんを抜粋ばっすいしました[21]。
関数かんすうの例れい
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    try stdout.print("{}\n", .{div(1, 0)});
    try stdout.print("{}\n", .{div(0, 0)});
}

fn div(f1: f64, f2: f64) f64 {
    return f1 / f2;
}
実行じっこう結果けっか
inf
nan
他たのプログラミング言語げんごをご存ぞんじの方ほうなら、関数かんすう div() が前方ぜんぽう参照さんしょうになっているのは大丈夫だいじょうぶなのか？と思おもわれるかもしれません。
Zigではトップレベルの識別子しきべつしは処理しょり系けいが参照さんしょう解決かいけつ（とシグネチャーを含ふくめた型かたの一致いっちの確認かくにん）を引受ひきうけてくれます。
  1. 基本きほん的てきな関数かんすうの定義ていぎ: Zigでの関数かんすうの定義ていぎは、以下いかのように行おこないます。 
    fn add(a: i8, b: i8) i8 {
    return a + b;
}
    この例れいでは、addという関数かんすうが定義ていぎされており、2つのi8型かたの引数ひきすうを受うけ取とり、i8型かたの値ねを返かえします。
  2. 外部がいぶ関数かんすうの定義ていぎ: Zigでは、外部がいぶライブラリやAPIから関数かんすうを利用りようするために、externキーワードを使用しようして外部がいぶ関数かんすうを宣言せんげんします。 
    extern "kernel32" fn ExitProcess(exit_code: u32) callconv(WINAPI) noreturn;
    この例れいでは、Windowsのkernel32ライブラリからExitProcessという関数かんすうを使用しようしています。
  3. パラメータの型かた推論すいろん: 関数かんすうのパラメータの型かたは、anytypeを使用しようして関数かんすうが呼よび出だされるときに推論すいろんされます。 
    fn addFortyTwo(x: anytype) @TypeOf(x) {
    return x + 42;
}
    この例れいでは、addFortyTwo関数かんすうのパラメータxの型かたが呼よび出だし時じに推論すいろんされます。
  4. インライン関数かんすう: inlineキーワードを使用しようすることで、関数かんすうをコールサイトにインライン展開てんかいすることができます。 
    inline fn foo(a: i32, b: i32) i32 {
    return a + b;
}
    この例れいでは、foo関数かんすうがインラインで展開てんかいされ、コンパイル時じに計算けいさんが行おこなわれます。
  5. 関数かんすうポインタ: 関数かんすうを値ねとして扱あつかうために、関数かんすうポインタを使用しようすることができます。 
    const Call2Op = *const fn (a: i8, b: i8) i8;
fn doOp(fnCall: Call2Op, op1: i8, op2: i8) i8 {
    return fnCall(op1, op2);
}
    この例れいでは、Call2Op型かたの関数かんすうポインタを引数ひきすうとして受うけ取とり、その関数かんすうを呼よび出だします。

Zigの関数かんすうは、柔軟じゅうなん性せいがあり、さまざまな目的もくてきに使用しようできます。関数かんすうは、プログラムの構造こうぞう化かと再さい利用りよう性せいを高たかめるために不可欠ふかけつな要素ようそです。

エラー

[編集へんしゅう]

Zigでは、エラー( Errors )も１ひとつの型かたです[34]。

エラー集合しゅうごう型がた

[編集へんしゅう]

エラー集合しゅうごう型かた( Error Set Type )は、enum のようなものです。同おなじエラー名めいを複ふく数すう回かい宣言せんげんすることは可能かのうで、宣言せんげんした場合ばあいは同おなじ整数せいすう値ちが割わり当あてられます[35]。 コンパイル全体ぜんたいのユニークなエラー値ちの数かずが、エラー集合しゅうごう型がたのサイズを決定けっていするはずです。しかし、いま[36]は u16 になるようにハードコーディングされています。 サブセットからスーパーセットへエラーを強制きょうせいすることができます。

構文こうぶん(EBNF)
error-set-decl = "error" "{" identifier-list "}"
[21]
エラー集合しゅうごう型がたの例れい
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const FileOpenError = error {
    AccessDenied,
    OutOfMemory,
    FileNotFound,
};

const AllocationError = error {
    OutOfMemory,
};

pub fn main() !void {
    try stdout.print("AllocationError.OutOfMemory == FileOpenError.OutOfMemory ⇒ {}\n", .{AllocationError.OutOfMemory == FileOpenError.OutOfMemory});
}
実行じっこう結果けっか
AllocationError.OutOfMemory == FileOpenError.OutOfMemory ⇒ true
エラー集合しゅうごうのマージ
[編集へんしゅう]

エラー集合しゅうごう型がたをマージするには、|| 演算えんざん子こを使用しようします。 結果けっかとして得えられるエラー集合しゅうごう型がたには、両方りょうほうのエラー集合しゅうごう型がたのエラーが含ふくまれます。

グローバルエラー集合しゅうごう
[編集へんしゅう]

anyerror は、グローバルエラー集合しゅうごうを参照さんしょうします。これは、コンパイルユニット全体ぜんたいのすべてのエラーを含ふくむエラー集合しゅうごうです。これは他たのすべてのエラー集合しゅうごうのスーパーセットで、どのエラー集合しゅうごうのサブセットでもありません。

任意にんいのエラー集合しゅうごうをグローバルエラー集合しゅうごうに強制きょうせいすることができ、グローバルエラー集合しゅうごうのエラーを非ひグローバルエラー集合しゅうごうに明示めいじ的てきにキャストすることができます。この場合ばあい、言語げんごレベルのアサートが挿入そうにゅうされ、エラー値ちが宛先あてさきのエラー集合しゅうごうに実際じっさいに含ふくまれていることが確認かくにんされます。

グローバルエラー集合しゅうごうは、コンパイラーがコンパイル時じにどのようなエラーが起おこりうるかを知しることができないため、一般いっぱんに避さけるべきです。コンパイル時じにエラー集合しゅうごうを知しっていた方ほうが、生成せいせいされるドキュメントや有用ゆうようなエラーメッセージ（例たとえば switch で起おこりうるエラー値ちを忘わすれてしまうなど）に有利ゆうりです。

エラーユニオン型がた

[編集へんしゅう]

エラー集合しゅうごう型がたと正常せいじょう型がたを二に項こう演算えんざん子こ ! で結合けつごうして、エラーユニオン型がた( Error Union Type )にすることができます。 

var error_or_value: AllocationError ! u16 = 10;

エラーユニオン型がたは、エラー集合しゅうごう型がた単体たんたいよりも頻繁ひんぱんに使用しようされる可能かのう性せいがあります[37]。

構文こうぶん(EBNF)
error-union-expr = suffix-expr ( "!" TypeExpr )?
suffix-expr = "async" PrimaryTypeExpr SuffixOp* FnCallArguments
            |       PrimaryTypeExpr ( SuffixOp | FnCallArguments )*
[21]

演算えんざん子こ

[編集へんしゅう]

Zigには、演算えんざん子このオーバーロードはありません。 Zigのプログラムに演算えんざん子こを見みたとき、それが次つぎの一覧いちらん表ひょうに示しめすもので、それ以外いがいのものでないことが保証ほしょうされます[38]。

演算えんざん子こ一覧いちらん表ひょう

[編集へんしゅう]
演算えんざん子こ一覧いちらん表ひょう( Table of Operators )[39]
構文こうぶん 関連かんれんする型かた 説明せつめい コード例れい 
a + b
a += b
加算かさん
整数せいすうの場合ばあい、オーバーフローを起おこす可能かのう性せいがあります。
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
「@addWithOverflow」も参照さんしょう
 
2 + 5 == 7

a +% b
a +%= b
ラッピング加算かさん
二にの補数ほすうのラップ動作どうさが保証ほしょうされています。
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
「@addWithOverflow」も参照さんしょう
 
@as(u32, std.math.maxInt(u32)) +% 1 == 0

a +| b
a +|= b
飽和ほうわ加算かさん
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
 
@as(u32, std.math.maxInt(u32)) +| 1 == @as(u32, std.math.maxInt(u32))

a - b
a -= b
減算げんざん
整数せいすうの場合ばあい、オーバーフローを起おこす可能かのう性せいがあります。
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
「@subWithOverflow」も参照さんしょう
 
2 - 5 == -3

a -% b
a -%= b
ラッピング減算げんざん
二にの補数ほすうのラップ動作どうさが保証ほしょうされています。
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
「@subWithOverflow」も参照さんしょう
 
@as(u32, 0) -% 1 == std.math.maxInt(u32)

a -| b
a -|= b
飽和ほうわ減算げんざん
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
 
@as(u32, 0) -| 1 == 0

-a
符号ふごう反転はんてん
整数せいすうの場合ばあい、オーバーフローを起おこす可能かのう性せいがあります。
 
-1 == 0 - 1

-%a
ラッピング符号ふごう反転はんてん
二にの補数ほすうのラップ動作どうさが保証ほしょうされています。
 
-%@as(i32, std.math.minInt(i32)) == std.math.minInt(i32)

a * b
a *= b
乗算じょうざん
整数せいすうの場合ばあい、オーバーフローを起おこす可能かのう性せいがあります。
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
「@mulWithOverflow」も参照さんしょう
 
2 * 5 == 10

a *% b
a *%= b
ラッピング乗算じょうざん
二にの補数ほすうのラップ動作どうさが保証ほしょうされています。
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
「@mulWithOverflow」も参照さんしょう
 
@as(u8, 200) *% 2 == 144

a *| b
a *|= b
* 整数せいすう
飽和ほうわ乗算じょうざん
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
 
@as(u8, 200) *| 2 == 255

a / b
a /= b
除算じょざん
整数せいすうの場合ばあい、オーバーフローを起おこす可能かのう性せいがあります。
整数せいすうの場合ばあい、ゼロ除算じょざんを起おこす可能かのう性せいがあります。
FloatMode.Optimized モードに於おいて、浮動ふどう小数点しょうすうてん数すうに対たいしてゼロ除算じょざんが発生はっせいすることがあります。
符号ふごう付つき整数せいすうのオペランドは、既知きち( comptime-known )かつ正せいでなければなりません。その他たの場合ばあいは、@divTrunc、@divFloor、または @divExact を代かわりに使用しようしてください。
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
 
10 / 5 == 2

a % b
a %= b
剰余じょうよ演算えんざん
整数せいすうの場合ばあい、ゼロ除算じょざんを起おこす可能かのう性せいがあります。
FloatMode.Optimized モードに於おいて、浮動ふどう小数点しょうすうてん数すうに対たいしてゼロ除算じょざんが発生はっせいすることがあります。
符号ふごう付つきまたは浮動ふどう小数点しょうすうてんオペランドは、既知きちで正せいの値ねでなければなりません。それ以外いがいの場合ばあいは、代かわりに @rem または @mod を使用しようしてください。
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
 
10 % 3 == 1

a << b
a <<= b

* 整数せいすう
左ひだりビットシフト
b は、既知きちであるか、aのビット数すうの log2 を持もつ型かたでなければなりません。
「@shlExact」および「@shlWithOverflow」も参照さんしょう
 
1 << 8 == 256

a <<| b
a <<|= b

* 整数せいすう
飽和ほうわ左ひだりビットシフト
「@shlExact」および「@shlWithOverflow」も参照さんしょう
 
@as(u8, 1) <<| 8 == 255

a >> b
a >>= b

* 整数せいすう
右みぎビットシフト
b は、既知きちであるか、aのビット数すうの log2 を持もつ型かたでなければなりません。
「@shrExact」も参照さんしょう
 
10 >> 1 == 5

a & b
a &= b
ビット論理ろんり積せき
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
 
0b011 & 0b101 == 0b001

a | b
a |= b
ビット論理ろんり和わ
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
 
0b010 | 0b100 == 0b110

a ^ b
a ^= b
ビット排他はいた的てき論理ろんり和わ
オペランドに対たいしてピア型がた解決かいけつを行おこないます。
 
0b011 ^ 0b101 == 0b110

~a
ビット反転はんてん
 
~@as(u8, 0b10101111) == 0b01010000

a orelse b
もし aがnullならば、b（"デフォルト値ち"）を返かえす、そうでなければ，ラップされていない a の値ねを返かえす。b がnoreturn型がたの値ねである可能かのう性せいがあることに注意ちゅうい。 
const value: ?u32 = null;
const unwrapped = value orelse 1234;
unwrapped == 1234

a.?
以下いかに同おなじ
a orelse unreachable

const value: ?u32 = 5678;
 value.? == 5678

a catch b
a catch |err| b
もし aがerrorならば、b（"デフォルト値ち"）を返かえす、そうでなければ，ラップされていない a の値ねを返かえす。code>b がnoreturn型がたの値ねである可能かのう性せいがあることに注意ちゅうい。 errはエラーであり，式しきbのスコープ内ないにある。 
const value: anyerror!u32 = error.Broken;
const unwrapped = value catch 1234;
unwrapped == 1234

a and b
論理ろんり積せき
もし a が false ばらば b を評価ひょうかせずに false を返かえす。そうでなければ b を返かえす。
 
(false and true) == false

a or b
論理ろんり和わ
もし a が true ばらば b を評価ひょうかせずに true を返かえす。そうでなければ b を返かえす。
 
(false or true) == true

!a
論理ろんり否定ひてい 
!false == true

a == b
a と b が等ひとしい場合ばあいは true を、そうでない場合ばあいは false を返かえします。オペランドに対たいしてピア型がた解決かいけつを行おこないます。 
(1 == 1) == true

a == null
a が null の場合ばあいは true を、そうでない場合ばあいは false を返かえします。 
const value: ?u32 = null;
value == null

a != b
a と b が等ひとしい場合ばあいは false を、そうでない場合ばあいは true を返かえします。オペランドに対たいしてピア型がた解決かいけつを行おこないます。 
(1 != 1) == false

a > b
a が b より大おおきい場合ばあいは true を、そうでない場合ばあいは false を返かえします。オペランドに対たいしてピア型がた解決かいけつを行おこないます。 
(2 > 1) == true

a >= b
a が b より大おおきいあるいは等ひとしい場合ばあいは true を、そうでない場合ばあいは false を返かえします。オペランドに対たいしてピア型がた解決かいけつを行おこないます。 
(2 >= 1) == true

a < b
a が b より小ちいさい場合ばあいは true を、そうでない場合ばあいは false を返かえします。オペランドに対たいしてピア型がた解決かいけつを行おこないます。 
(1 < 2) == true
> 
a <= b
a が b より小ちいさいあるいは等ひとしい場合ばあいは true を、そうでない場合ばあいは false を返かえします。オペランドに対たいしてピア型がた解決かいけつを行おこないます。 
(1 <= 2) == true

a ++ b
配列はいれつの結合けつごう
a と b が既知きちの場合ばあいのみ使用しよう可能かのうです。
 
const mem = @import("std").mem;
const array1 = [_]u32{1,2};
const array2 = [_]u32{3,4};
const together = array1 ++ array2;
mem.eql(u32, &together, &[_]u32{1,2,3,4})

a ** b
配列はいれつの乗算じょうざん
a と b が既知きちの場合ばあいのみ使用しよう可能かのうです。
 
const mem = @import("std").mem;
const pattern = "ab" ** 3;
mem.eql(u8, pattern, "ababab")

a.*
ポインターのデリファレンス
 
const x: u32 = 1234;
const ptr = &x;
ptr.* == 1234

&a
すべて
アドレスを取得しゅとく
 
const x: u32 = 1234;
const ptr = &x;
ptr.* == 1234

a || b
エラー集合しゅうごうのマージ
 
const A = error{One};
const B = error{Two};
(A || B) == error{One, Two}

オーバーフロー

[編集へんしゅう]

Zigでは、四則しそく演算えんざんなどの演算えんざん子こはディフォルトでオーバーフローを検出けんしゅつします。それとは別べつに、（C言語げんごなどのように）ラッピングを行おこなう演算えんざん子こが別べつに用意よういされています。

オーバーフローの例れい
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var r :i3 = 0;
    while (r < 10) : (r += 1){
        try stdout.print("{} ", .{r});
    }
}
実行じっこう結果けっか
An error occurred: 
0 1 2 3 thread 7015 panic: integer overflow 
/tmp/playground2097195080/play.zig:6:25: 0x22cff6 in main (play) 
   while (r < 10) : (r += 1){ 
                       ^ 
/usr/local/bin/lib/std/start.zig:561:37: 0x22657a in std.start.callMain (play) 
           const result = root.main() catch |err| { 
                                   ^ 
/usr/local/bin/lib/std/start.zig:495:12: 0x20716e in std.start.callMainWithArgs (play) 
   return @call(.{ .modifier = .always_inline }, callMain, .{}); 
          ^ 
/usr/local/bin/lib/std/start.zig:409:17: 0x206206 in std.start.posixCallMainAndExit (play) 
   std.os.exit(@call(.{ .modifier = .always_inline }, callMainWithArgs, .{ argc, argv, envp })); 
               ^ 
/usr/local/bin/lib/std/start.zig:322:5: 0x206012 in std.start._start (play) 
   @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{}); 
   ^
符号ふごう付つき３ビット整数せいすうの r を r < 10 の間あいだインクリメントしています。
符号ふごう付つき３ビット整数せいすうは、 -4 ... 3 の値ねしか表あらわせず 4 になるとオーバーフローします。
C言語げんごなどでは、無限むげんループになりますが Zig ではランタイムに検出けんしゅつされます。

飽和ほうわ演算えんざん

[編集へんしゅう]

Zigには、四則しそく演算えんざんなどの演算えんざん子こに飽和ほうわ演算えんざん( Saturation calculation )バージョンが用意よういされています。

飽和ほうわ演算えんざんの例れい
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var i: i5 = 0;
    var sum: i5 = 0;
    while (i < 10) : (i += 1) {
        sum +|= i;
        try stdout.print("i = {}, sum = {}\n", .{ i, sum });
    }
}
実行じっこう結果けっか
i = 0, sum = 0 
i = 1, sum = 1 
i = 2, sum = 3 
i = 3, sum = 6 
i = 4, sum = 10 
i = 5, sum = 15 
i = 6, sum = 15 
i = 7, sum = 15 
i = 8, sum = 15 
i = 9, sum = 15

優先ゆうせん順位じゅんい

[編集へんしゅう]

高こう 

 x() x[] x.y x.* x.?
 a!b
 x{}
 !x -x -%x ~x &x ?x
 * / % ** *% *| ||
 + - ++ +% -% +| -|
 << >> <<|
 & ^ | orelse catch
 == != < > <= >=
 and
 or
 = *= *%= *|= /= %= += +%= +|= -= -%= -|= <<= <<|= >>= &= ^= |=

低ひく

オプショナル型がた

[編集へんしゅう]

Zigには「オプショナル型がた」( optional type )と「非ひオプショナル型がた」があります。

オプショナル型がた
値ねとしてnullを受うけ入いれられる。
非ひオプショナル型がた
値ねとしてnullを受うけ入いれられない。

ここまでに紹介しょうかいした変数へんすうおよび定数ていすうの型かたは非ひオプショナル型がたです。

オプショナル型がたの変数へんすうおよび定数ていすうは宣言せんげんのときに ?型名かためい と書かきます。 

var a: i32 = null;  // 非ひオプショナル型がたを null で初期しょき化かするとエラーになる！
var b: ?i32 = null; // オプショナル型がたは null で初期しょき化かしてもエラーにならない

アンラップ

[編集へんしゅう]

オプショナル型がたの式しきから基底きてい型がたの値ねを参照さんしょうすることをアンラップを呼よびます。

ifを使つかったアンラップ
const std = @import("std");
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var s: ?[]const u8 = null;

    if (s) |ss| {
        try stdout.print("{s}\n", .{ss});
    } else {
        try stdout.writeAll("it's null\n");
    }

    s = "abc";

    if (s) |ss| {
        try stdout.print("{s}\n", .{ss});
    } else {
        try stdout.writeAll("it's null\n");
    }
}
実行じっこう結果けっか
it's null
abc

配列はいれつ

[編集へんしゅう]

Zigの配列はいれつは、次つぎのような特徴とくちょうを持もちます：

配列はいれつの定義ていぎ
  • 配列はいれつリテラル：const array = [_]u8{'h', 'e', 'l', 'l', 'o'}
  • 配列はいれつサイズの取得しゅとく：array.len
  • 配列はいれつの要素ようそアクセス：array[index]
配列はいれつの操作そうさ
  • 配列はいれつの反復はんぷく処理しょり：for (array) |item| { ... }
  • 配列はいれつの変更へんこう：array[index] = value
  • 配列はいれつの結合けつごう：const concatenated = array1 ++ array2
コンパイル時じ初期しょき化か
  • コンパイル時じに配列はいれつの初期しょき化かが可能かのう
  • コンパイル時じコードでの配列はいれつ操作そうさ
多次元たじげん配列はいれつ
  • 配列はいれつのネストにより多次元たじげん配列はいれつを作成さくせい可能かのう
  • 多次元たじげん配列はいれつの反復はんぷく処理しょり
センチネル終端しゅうたん配列はいれつ
  • センチネル終端しゅうたん配列はいれつの定義ていぎ
  • センチネル終端しゅうたん配列はいれつの操作そうさ

Zigの配列はいれつは柔軟じゅうなんで効率こうりつ的てきなデータ構造こうぞうであり、様々さまざまなアプリケーションで使用しようされます。

構文こうぶん(EBNF)
array-type-start = "[" expr [ ":" expr ] "]"
[21]

配列はいれつと特殊とくしゅな演算えんざん子こ ++ と **

[編集へんしゅう]

配列はいれつには、特有とくゆうな演算えんざん子こが２ふたつあります。

配列はいれつのコード例れい
const stdout = @import("std").io.getStdOut().writer();

pub fn main() !void {
    const ary = [_]i8{ 2, 3, 5, 7 };

    try stdout.print("ary == {}{{ ", .{@TypeOf(ary)});
    for (ary) |elm| {
        try stdout.print("{}, ", .{elm});
    }
    try stdout.writeAll("}\n");

    try stdout.print("ary ++ ary == {}{{ ", .{@TypeOf(ary ++ ary)});
    for (ary ++ ary) |elm| {
        try stdout.print("{}, ", .{elm});
    }
    try stdout.writeAll("}\n");

    try stdout.print("ary ** 3 == {}{{ ", .{@TypeOf(ary ** 3)});
    for (ary ** 3) |elm| {
        try stdout.print("{}, ", .{elm});
    }
    try stdout.writeAll("}\n");
}
実行じっこう結果けっか
ary == [4]i8{ 2, 3, 5, 7, } 
ary ++ ary == [8]i8{ 2, 3, 5, 7, 2, 3, 5, 7, } 
ary ** 3 == [12]i8{ 2, 3, 5, 7, 2, 3, 5, 7, 2, 3, 5, 7, }
省略しょうりゃく記法きほう
const ary = [_]i8{ 2, 3, 5, 7 };
は
完全かんぜんな表記ひょうき
const ary: [4]i8= [4]i8{ 2, 3, 5, 7 };
ですが、型かたは型かた推定すいていで、要素ようそ数すうもリテラルなので _ と書かけます。
配列はいれつ連結れんけつ演算えんざん子こ
ary ++ ary
++ は配列はいれつと配列はいれつを連結れんけつした新あたらしい配列はいれつを返かえす演算えんざん子こです。
配列はいれつ連結れんけつ演算えんざん子こ
ary ** 3
** は配列はいれつを回数かいすうだけ繰返くりかえした新あたらしい配列はいれつを返かえす演算えんざん子こです。
ary ** ary は ary ++ ary ++ ary と等価とうかです。

多次元たじげん配列はいれつ

[編集へんしゅう]

多次元たじげん配列はいれつ( Multidimensional Arrays )は、ネストした配列はいれつで生成せいせいします[40]。

多次元たじげん配列はいれつ
const stdout = @import("std").io.getStdOut().writer();

pub fn main() !void {
    var matrix: [16][16]i32 = undefined;

    // 全ぜん成分せいぶんを 0 に
    for (&matrix) |*col| {
        for (&col.*) |*value| {
                value.* = 0;
        }
    }
    try stdout.print("martix == {}{{\n", .{@TypeOf(matrix)});
    for (matrix) |col| {
        try stdout.writeAll("  { ");
        for (col) |value| {
            try stdout.print("{}, ", .{value});
        }
        try stdout.writeAll("},\n");
    }
    try stdout.writeAll("}\n\n");

    // 対たい角かく成分せいぶんを 1 に
    for (&matrix, 0..) |*col, ci| {
        for (&col.*, 0..) |*value, ri| {
            if (ci == ri) {
                value.* = 1;
            }
        }
    }

    try stdout.print("martix == {}{{\n", .{@TypeOf(matrix)});
    for (matrix) |col| {
        try stdout.writeAll("  { ");
        for (col) |value| {
            try stdout.print("{}, ", .{value});
        }
        try stdout.writeAll("},\n");
    }
    try stdout.writeAll("}\n");
}
実行じっこう結果けっか
martix == [16][16]i32{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
}

martix == [16][16]i32{
  { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, },
}
多次元たじげん配列はいれつの宣言せんげん
    var matrix : [16][16]i32 = undefined;
undefined で初期しょき化かしています。というより初期しょき化かしていません。
スカラで配列はいれつの初期しょき化かはできません
    var matrix : [16][16]i32 = 0; // これはエラーになる
と書かきたいところですができないので、二に重じゅうのforループで初期しょき化かしています。

センチネル終端しゅうたん配列はいれつ

[編集へんしゅう]

センチネル終端しゅうたん配列はいれつ( Sentinel Terminated Arrays )は、文字もじ列れつのように特殊とくしゅな値あたい（センチネル（ sentinel；番兵ばんぺい ））で終端しゅうたんした配列はいれつです。 文字もじ列れつの場合ばあいのセンチネルは ’\0’ ですが、構文こうぶん [配列はいれつ長ちょう:x]要素ようそ型がた の x で任意にんいの値ねをセンチネルにできます[41]。

センチネル終端しゅうたん配列はいれつ
const stdout = @import("std").io.getStdOut().writer();

pub fn main() !void {
    const ary = [_:-1]i32{ 1, 4, 9, 16, 25 };
    try stdout.print("@TypeOf(ary) ⇒ {}\n", .{@TypeOf(ary)});
    var i: u16 = 0;
    while (i <= ary.len) : (i += 1) {
        try stdout.print("{} ", .{ary[i]});
    }
}
実行じっこう結果けっか
@TypeOf(ary) ⇒ [5:-1]i32 
1 4 9 16 25 -1
「センチネル終端しゅうたんポインター」および「センチネル終端しゅうたんスライス」も参照さんしょう

ベクトル

[編集へんしゅう]

ベクトルは、bool、整数せいすう、浮動ふどう小数点しょうすうてん数すう、ポインターのグループで、可能かのうであればSIMD命令めいれいを使つかって並列へいれつに操作そうさされます。ベクトル型がたは、組込くみこみ関数かんすう @Vector で作成さくせいします[42]。

ベクトルは、基本きほん型がたと同おなじ組くみ込こみ演算えんざん子こをサポートしています。これらの演算えんざんは要素ようそごとに行おこなわれ、入力にゅうりょくベクトルと同おなじ長ながさのベクトルを返かえします。これには以下いかが含ふくまれます。

算術さんじゅつ演算えんざん
+, -, /, *, @divFloor, @sqrt, @ceil, @log, など
ビット演算えんざん子こ
>>, <<, &, |, ~, など
比較ひかく演算えんざん子こ
<, >, ==, など

スカラー（個々ここの数値すうち）とベクトルが混在こんざいしている場合ばあいに数学すうがく演算えんざん子こを使用しようすることは禁止きんしされています。Zigでは、スカラーからベクトルへの変換へんかんを容易よういにするために組込くみこみ関数かんすう@splatが用意よういされており、ベクトルからスカラーへの変換へんかんには組込くみこみ関数かんすう@reduceと配列はいれつインデックスの構文こうぶんがサポートされています。ベクトルは、長ながさが既知きちの固定こてい長ちょうの配列はいれつとの間あいだの代入だいにゅうもサポートしています。

Zigは，組込くみこみ関数かんすう@shuffleと組込くみこみ関数かんすう@selectを提供ていきょうし，ベクトル内ないやベクトル間あいだの要素ようその並ならべ替がえを行おこないます．

ターゲットマシンのネイティブ SIMD サイズより短みじかいベクトルに対たいする操作そうさは、通常つうじょうは単一たんいつの SIMD 命令めいれいにコンパイルされます。ある演算えんざんがターゲット・アーキテクチャで SIMD をサポートしていない場合ばあい、コンパイラーはデフォルトで各かくベクトル要素ようそに対たいして一いち度どに 1 つずつ演算えんざんします。Zig は、232-1 までの既知きちのベクトル長ちょうをサポートしていますが、2 の累乗るいじょう（2-64）が最もっとも一般いっぱん的てきです。ただし、現在げんざいの Zig では、長ながすぎるベクトル長ちょう (例たとえば 220) はコンパイラーがクラッシュする可能かのう性せいがあります。

ベクトル演算えんざん
const stdout = @import("std").io.getStdOut().writer();

pub fn main() !void {
    const a = @Vector(4, i32){ 1, 2, 3, 4 };
    const b = @Vector(4, i32){ 5, 6, 7, 8 };

    try stdout.print("  {}\n+ {}\n= {}\n\n", .{ a, b, a + b });
    try stdout.print("  {}\n- {}\n= {}\n\n", .{ a, b, a - b });
    try stdout.print("  {}\n* {}\n= {}\n\n", .{ a, b, a * b });
    try stdout.print("  {}\n/ {}\n= {}\n\n", .{ a, b, a / b });
    try stdout.print("  {}\n% {}\n= {}\n\n", .{ a, b, a % b });
}
実行じっこう結果けっか
  { 1, 2, 3, 4 } 
+ { 5, 6, 7, 8 } 
= { 6, 8, 10, 12 }
  
  { 1, 2, 3, 4 }
- { 5, 6, 7, 8 } 
= { -4, -4, -4, -4 }

  { 1, 2, 3, 4 } 
* { 5, 6, 7, 8 } 
= { 5, 12, 21, 32 }

  { 1, 2, 3, 4 } 
/ { 5, 6, 7, 8 } 
= { 0, 0, 0, 0 } 

  { 1, 2, 3, 4 } 
% { 5, 6, 7, 8 } 
= { 1, 2, 3, 4 }

[TODO:配列はいれつとの相互そうご変換へんかん]

ポインター

[編集へんしゅう]

Zigには、単一たんいつ項目こうもくと多項目たこうもくの2種類しゅるいのポインターがあります[43]。

  • *T - 正確せいかくに1つの項目こうもくへの単一たんいつ項目こうもくポインター。
    • deref構文こうぶんをサポート: ptr.*
  • [*]T - 未知数みちすうのアイテムへの多項目たこうもくポインター。
    • インデックス構文こうぶんをサポート: ptr[i]
    • スライス構文こうぶんをサポート: ptr[start..end]
    • ポインター演算えんざんをサポート: ptr + x, ptr - x
    • T は既知きちのサイズでなければならず、anyopaqueや他たの opaque型がた にはできません。

これらの型かたは、配列はいれつやスライスと密接みっせつに関係かんけいしています。

  • *[N]T - N 個このアイテムへのポインター、配列はいれつへの単たん項目こうもくポインターと同おなじです。
    • インデックス構文こうぶんに対応たいおう: array_ptr[i]
    • スライス構文こうぶんに対応たいおう: array_ptr[start..end]
    • lenプロパティをサポート: array_ptr.len
  • []T - スライス (ファットポインター。[*]T型がたのポインターと長ながさを含ふくみます）。
    • インデックス構文こうぶんに対応たいおう: slice[i]
    • スライス構文こうぶんに対応たいおう: slice[start..end]
    • lenプロパティをサポート: slice.len

単一たんいつ項目こうもくポインター

[編集へんしゅう]

単たん項目こうもくポインターを得えるには、&xを使用しようします。

多項目たこうもくポインター

[編集へんしゅう]

[TODO]

volatile

[編集へんしゅう]

ロードとストアは、副作用ふくさようがないことが前提ぜんていです。MMIO (Memory Mapped Input/Output) のように、ロードやストアが副作用ふくさようを持もつべき場合ばあいは volatile を使用しようします[44]。

アライメント

[編集へんしゅう]

それぞれの型かたにはアライメント( Alignment )があり、その型かたの値ねがメモリーからロードされたり、メモリーにストアされたりするとき、メモリーアドレスがこの数かずで均等きんとうに割わり切きれるようなバイト数すうになっています。この値ねは組込くみこみ関数かんすう @alignOf を使つかって知しることができます[45]。

アラインメントはCPUアーキテクチャに依存いぞんしますが、常つねに2のべき乗じょうであり、1 << 29 より小ちいさい値ねです。

Zigでは、ポインター型かたはアライメント値ちを持もっています。この値ねが基礎きそとなる型かたのアライメントと等ひとしい場合ばあい、その型かたは省略しょうりゃくすることができます。

align
[編集へんしゅう]

align は、ポインターのアライメントを指定していするために使用しようします。また、変数へんすうや関数かんすうの宣言せんげんの後のちに使用しようして、その変数へんすうや関数かんすうへのポインターのアライメントを指定していすることができます。

allowzero

[編集へんしゅう]

allowzeroポインター属性ぞくせいは、ポインターのアドレスがゼロであることを許可きょかします。これは、アドレスゼロがマッピング可能かのうな独立どくりつ型がたOSターゲットでのみ必要ひつようとされます。nullポインターを表現ひょうげんしたい場合ばあいは、代かわりにオプショナルポインターを使用しようします。allowzeroを持もつオプショナルポインターは、ポインターと同おなじサイズではありません[46]。

const

[編集へんしゅう]

constポインター属性ぞくせいは、（ポインターではなく）ポインターが参照さんしょうする値ねが変更へんこうできないことを示しめします。

センチネル終端しゅうたんポインター

[編集へんしゅう]

センチネル終端しゅうたんポインター( Sentinel Terminated Pointers )。 構文こうぶん [*:x]T は、センチネル値ちによって長ながさが決定けっていされるポインターを記述きじゅつします。これにより、バッファオーバーフローやオーバーリードから保護ほごされます[47]。

「#センチネル終端しゅうたん配列はいれつ」および「#センチネル終端しゅうたんスライス」も参照さんしょう

スライス

[編集へんしゅう]

スライス( Slices )はポインターと長ながさです。配列はいれつとスライスの違ちがいは、配列はいれつの長ながさが型かたの一部いちぶでコンパイル時じにわかるのに対たいして、スライスの長ながさは実行じっこう時じにわかることです。どちらも len プロパティでアクセスすることができます[48]。

スライスを使つかったコード例れい
const stdout = @import("std").io.getStdOut().writer();

pub fn main() !void {
    var array = [_]i32{ 2, 3, 5, 7, 11, 13, 17 };
    var q: usize = 1;
    const slice = array[q .. array.len -1];

    try stdout.print("@TypeOf(slice) ⇒ {}\n", .{@TypeOf(slice)});
    for (slice) |x| {
        try stdout.print("{} ", .{x});
    }
}
実行じっこう結果けっか
@TypeOf(slice) ⇒ []i32 
3 5 7 11 13

センチネル終端しゅうたんスライス

[編集へんしゅう]

センチネル終端しゅうたんスライス( Sentinel-Terminated Slices )。 構文こうぶん[:x]Tは、実行じっこう時じに既知きちの長ながさを持もち、また長ながさでインデックスされた要素ようそで センチネル値ちを保証ほしょうするスライスです。この型かたは、それ以前いぜんにセンチネル要素ようそがないことを保証ほしょうするものではありません。センチネル終端しゅうたんスライスはlenインデックスへのエレメントアクセスを可能かのうにします[49]。

スライスを使つかったコード例れい
const stdout = @import("std").io.getStdOut().writer();

pub fn main() !void {
    const slice: [:0]const u8 = "hello";

    try stdout.print("@TypeOf(slice) ⇒ {}\n", .{@TypeOf(slice)});
    for (slice) |ch| {
        try stdout.print("{c} ", .{ch});
    }
}
実行じっこう結果けっか
@TypeOf(slice) ⇒ [:0]const u8 
h e l l o
「センチネル終端しゅうたん配列はいれつ」および「センチネル終端しゅうたんポインター」も参照さんしょう

コンテナー

[編集へんしゅう]

コンテナー（Containers）とは、変数へんすうや関数かんすうの宣言せんげんを保持ほじする名前なまえ空間くうかんとして機能きのうする構文こうぶん上じょうの構造こうぞうです。コンテナーは、インスタンス化か可能かのうな型かた定義ていぎでもあります。struct、enum、unionとopaque そしてZigのソースファイル自体じたいも、コンテナーの例れいです。

コンテナーは、定義ていぎを囲かこむために波なみ括弧かっこを使用しようしますが、ブロックや関数かんすうとは異ことなります。コンテナーには文ぶんが含ふくまれていません。

[TODO:std.containerについて]

構文こうぶん(EBNF)
container-members = container-declarations ( container-field "," )* (container-field | container-declarations)
container-declarations = TestDecl container-declarations   
                      | TopLevelComptime container-declarations
                      | [ doc_comment ] [ "pub" ] TopLevelDecl container-declarations
                      | 
container-field = [ doc_comment ] [ "comptime" ] IDENTIFIER [ ":" ( "anytype" | TypeExpr)  [ ByteAlign ] ] [ "=" expr ]

container-decl-auto = container-decl-type "{" [ container_doc_comment ] container-members "}"
container-decl-type = "struct" 
                  | "opaque" 
                  | "enum" [ "(" expr ")" ]
                  | "union" [ "(" ( "enum" [ "(" expr ")" ] ) | expr  ")"
コンテナー関連かんれんの構文こうぶんを抜粋ばっすい[21]

struct

[編集へんしゅう]

struct（構造こうぞうあるいは構造こうぞう型がた[50]）はデータの集合しゅうごうを定義ていぎするための構文こうぶんであり、フィールドにはデフォルト値ちやメソッドを持もたせることができます。packed structやextern structといった特殊とくしゅな形式けいしきも提供ていきょうされ、メモリレイアウトを制御せいぎょします。関数かんすう内ないでのstructの生成せいせいやジェネリックな構造こうぞう体たいの定義ていぎもサポートされています。さらに、関数かんすうからstructを返かえすことも可能かのうです。

struct の定義ていぎ
const stdout = @import("std").io.getStdOut().writer();

const Complex = struct {
    real: f64,
    imag: f64,
};

pub fn main() !void {
    try stdout.print("@TypeOf(Complex) ⇒ {}\n", .{@TypeOf(Complex)});
}
実行じっこう結果けっか
@TypeOf(Complex) ⇒ type
3-6 行ぎょう目めが struct の宣言せんげんで、変数へんすうに保存ほぞんしています。
struct で宣言せんげんした値ねの型かたは type です。
ところで Zigはフィールドの順番じゅんばんとサイズを保証ほしょうしません。しかし、フィールドはABIアラインされていることが保証ほしょうされています[51]。
もし、順番じゅんばんとサイズを保証ほしょうしたい場合ばあいキーワード packed を前まえ置おけします。
順番じゅんばんとサイズを保証ほしょうしたい場合ばあい
const Complex = packed struct {
    real: f64,
    imag: f64,
};
インスタンスの生成せいせい
const stdout = @import("std").io.getStdOut().writer();

const Complex = struct {
    real: f64,
    imag: f64,
};

pub fn main() !void {
    const cplx = Complex{
        .real = 1.2,
        .imag = 4.1,
    };
    try stdout.print("{}\n", .{ cplx });
}
実行じっこう結果けっか
Complex{ .real = 1.2e+00, .imag = 4.1e+00 }
メンバー名めいの前まえに . が付つくのが独特どくとくです。
メンバーは常つねに pub です。
private や protected や friend はありません。
メソッド
[編集へんしゅう]

struct はメソッド( Methods )を持もつことができます。 メソッドは特別とくべつなものではなく、名前なまえ空間くうかんを持もつだけです。 ドットシンタックス（インスタンス名めい.メソッド名めい）で呼よび出だすことができる関数かんすうです。

メソッドの例れい
const stdout = @import("std").io.getStdOut().writer();
const sqrt = @import("std").math.sqrt;

const Complex = struct {
    real: f64,
    imag: f64,
    pub fn init(real: f64, imag: f64) Complex {
        return Complex{
            .real = real,
            .imag = imag,
        };
    }
    pub fn abs(self: Complex) f64 {
        return sqrt(self.real * self.real + self.imag * self.imag);
    }
};

pub fn main() !void {
    const cplx = Complex.init(3.3, 4.4);
    try stdout.print("cplx = {}\n", .{cplx});
    try stdout.print("cplx.abs() = {}\n", .{cplx.abs()});
    try stdout.print("Complex.abs(cplx) = {}\n", .{Complex.abs(cplx)});
}
実行じっこう結果けっか
cplx = Complex{ .real = 3.3e+00, .imag = 4.4e+00 } 
cplx.abs() = 5.5e+00 
Complex.abs(cplx) = 5.5e+00
インスタンスを生成せいせいするメソッド init() と絶対ぜったい値ちを返かえすメソッド abs() を定義ていぎしました。
インスタンスを生成せいせいするメソッドに init と名付なづけるのも、フィールドにアクセスするメソッドの第だい一いち引数ひきすうを self と名付なづけるのも言語げんご仕様しようではなく慣習かんしゅうですが、逸脱いつだつする積極せっきょく的てきな理由りゆうはありません。

[TODO:組込くみこみ関数かんすう＠This]

匿名とくめいstructリテラル
[編集へんしゅう]

Zigでは、structリテラルの型かたは識別子しきべつしと結むすびついている必要ひつようはありません。結果けっかが強制きょうせいされる場合ばあい、structリテラルはコピーなしで結果けっかの場所ばしょを直接ちょくせつインスタンス化かします。 この様ように、識別子しきべつしと結むすびついていないstructリテラルを、匿名とくめいstructリテラル( Anonymous Struct Literals )あるいはタプル( Tuple )と呼よびます[52]。

enum

[編集へんしゅう]

Zigのenumは列挙れっきょ型がたを定義ていぎするための構文こうぶんであり、異ことなる値ねをグループ化かします[53]。 値ねの順序じゅんじょを指定していせずに列挙れっきょ型がたを宣言せんげんすることができ、任意にんいの整数せいすう型がたを指定していしてタグ型がたを制御せいぎょできます。 タグ型がたを指定していしない場合ばあい、自動的じどうてきに整数せいすう型がたが割わり当あてられ、0から始はじまる連続れんぞくした値ねが与あたえられます。 列挙れっきょ型がたにはメソッドを追加ついかすることができ、switch文ぶんを使用しようして値ねを切きり替かえることができます。 また、列挙れっきょ型がたリテラルを使用しようして、特定とくていの列挙れっきょ値ちを指定していすることも可能かのうです。 Zigのenumは柔軟じゅうなん性せいが高たかく、CのABIとの互換ごかん性せいを保たもつための機能きのうも提供ていきょうされています。

enum の定義ていぎ
const stdout = @import("std").io.getStdOut().writer();

const Colour = enum {
    red,
    green,
    blue,
};

const JISC5062 = enum(u4) {
    black = 0,
    brown,
    red,
    orange,
    yellow,
    green,
    blue,
    violet,
    gray,
    white,

    const Self = @This();
    const len = @typeInfo(Self).Enum.fields.len;
    pub fn allCases() [Self.len]Self {
        var result: [Self.len]Self = undefined;
        var i: u4 = 0;
        while (i < Self.len) : (i += 1) {
            result[i] = @as(Self, @enumFromInt(i));
        }
        return result;
    }
};

pub fn main() !void {
    try stdout.print("@TypeOf(Colour) ⇒ {}\n", .{@TypeOf(Colour)});
    const c: Colour = .green;
    try stdout.print("c ⇒ {}\n", .{c});
    try stdout.print("JISC5062.allCases() ⇒ {any}\n", .{JISC5062.allCases()});
    for (JISC5062.allCases()) |e| {
        try stdout.print("{s} ⇒ {}\n", .{ @tagName(e), @intFromEnum(e) });
    }
}
実行じっこう結果けっか
@TypeOf(Colour) ⇒ type
c ⇒ main.Colour.green
JISC5062.allCases() ⇒ { main.JISC5062.black, main.JISC5062.brown, main.JISC5062.red, main.JISC5062.orange, main.JISC5062.yellow, main.JISC5062.green, main.JISC5062.blue, main.JISC5062.violet, main.JISC5062.gray, main.JISC5062.white }
black ⇒ 0
brown ⇒ 1
red ⇒ 2
orange ⇒ 3
yellow ⇒ 4
green ⇒ 5
blue ⇒ 6
violet ⇒ 7
gray ⇒ 8
white ⇒ 9
3-7,9-31行ぎょう目めが enum の宣言せんげんで、それぞれ変数へんすうに保存ほぞんしています。
enum で宣言せんげんした値ねの型かたは type です。
enum は、struct と同おなじくメンバーとは別べつに、型かたに属ぞくする変数へんすうやメソッドを持もつことが出来できます。
JISC5062.allCases() は、JISC5062のメンバー全すべてを含ふくむ配列はいれつを返かえしています。
const Self = @This();は、コンテナー定義ていぎでコンテナーの識別子しきべつしを書かく手間てまをなくし、コピーアンドペーストを容易よういにします。
red, green と blue が Colour と JISC5062 で重複じゅうふくしていますが、コンテナーは名前なまえ空間くうかんとして機能きのうするので問題もんだいになりません。
コードショーケース
[編集へんしゅう]
const std = @import("std");
const mem = std.mem;
const testing = std.testing;
const expect = testing.expect;

test "Enum w/ method" {
    // Enumを定義ていぎします。
    const Color = enum {
        red,
        green,
        blue,
    };

    // Enumフィールドを宣言せんげんします。
    const primaryColor: Color = .red;
    _ = primaryColor;

    // Enumメソッドを持もたせます。
    const Suit = enum {
        clubs,
        spades,
        diamonds,
        hearts,
        const Self = @This();

        pub fn isClubs(self: Self) bool {
            return self == Self.clubs;
        }
    };

    // Enumメソッドをテストします。
    const p = Suit.spades;
    try expect(!p.isClubs());
}
test "Enum w/ switch" {
    // Enumをスイッチで使用しようします。
    const Foo = enum {
        string,
        number,
        none,
    };
    const p2 = Foo.number;
    const what_is_it = switch (p2) {
        Foo.string => "This is a string",
        Foo.number => "This is a number",
        Foo.none => "This is none",
    };
    try expect(mem.orderZ(u8, what_is_it, "This is a number") == .eq);
}

test "Enum Literal " {
    // Enumリテラルを使用しようします。
    const Status = enum {
        ok,
        err,
    };
    const status1: Status = .ok;
    const status2 = Status.err;
    try expect(status1 != status2);
}

test "Non-exhaustive enum" {
    // 非ひ全ぜん網羅もうらEnumを作成さくせいします。
    const Shape = enum(u8) {
        circle,
        square,
        rectangle,
        _,
    };
    const shape = Shape.circle;
    const shapeMessage = switch (shape) {
        Shape.circle => "This is a circle",
        Shape.square => "This is a square",
        Shape.rectangle => "This is a rectangle",
        _ => "Unknown shape", // 非ひ全ぜん網羅もうらのため、_ で処理しょり
    };
    try expect(mem.orderZ(u8, shapeMessage, "This is a circle") == .eq);
}

union

[編集へんしゅう]

Zigのunionは、値ねが取とりうる可能かのうな型かたのセットをフィールドのリストとして定義ていぎしますす[54]。 一いち度どに1つのフィールドしかアクティブにできません。 裸はだかのUnionのメモリ表現ひょうげんは保証ほしょうされておらず、メモリを再さい解釈かいしゃくするためには@ptrCastを使用しようするか、保証ほしょうされたメモリレイアウトを持もつextern unionまたはpacked unionを使用しようする必要ひつようがあります。 非ひアクティブなフィールドへのアクセスは安全あんぜん性せいが確認かくにんされておらず、未定義みていぎの動作どうさになります。 Union全体ぜんたいを割わり当あてることで他たのフィールドをアクティブにできます。 また、Switch文ぶんを使用しようするためには、Unionにenumタグ型がたを付つける必要ひつようがあります。 これにより、Switch式しきでUnionのペイロードを変更へんこうすることが可能かのうになります。 Unionにはenumタグ型がたを推論すいろんさせることもでき、またstructやenumと同様どうようにメソッドを持もつことができます。

非ひアクティブフィールドを参照さんしょうするとコンパイルエラーになります
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const SimpleUnion = union {
    char: u8,
    int: i64,
    float: f64,
};

pub fn main() !void {
    var su = SimpleUnion{ .char = 'C' };
    try stdout.print("su.int = {}\n", .{su.int});
}
コンパイル結果けっか
panic: access of inactive union field
アクティブフィールドであれば参照さんしょうできます
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const SimpleUnion = union {
    char: u8,
    int: i64,
    float: f64,
};

pub fn main() !void {
    var su = SimpleUnion{ .char = 'C' };
    try stdout.print("su.char = {c}\n", .{su.char});
    su = SimpleUnion{ .int = 42 };
    try stdout.print("su.int = {}\n", .{su.int});
    su = SimpleUnion{ .float = 2.71828_18284_59045_23536_02874_71352 };
    try stdout.print("su.float = {}\n", .{su.float});
}
実行じっこう結果けっか
su.char = C
su.int = 42 
su.float = 2.718281828459045e+00
タグ付つきunion
[編集へんしゅう]

union はenumタグタイプを伴ともなって宣言せんげんすることができます。これにより unionは、タグ付つきunion( Tagged union )になり、switch式しきで使用しようすることができるようになります。タグ付つきunionは、そのタグ型がたに強制きょうせいされます[55]。

「型かた強制きょうせい: unionとenum」も参照さんしょう
タグ付つきunion
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const Tag = enum {
    char,
    int,
    float,
};

const TaggedUnion = union(Tag) {
    char: u8,
    int: i64,
    float: f64,
};

pub fn main() !void {
    var tu = TaggedUnion{ .char = 'C' };
    try stdout.print("@as(Tag, tu) ⇒ {}\n", .{@as(Tag, tu)});
    switch (tu) {
        Tag.char => |ch| try stdout.print("ch = {c}\n", .{ch}),
        Tag.int => |i| try stdout.print("i = {}\n", .{i}),
        Tag.float => |f| try stdout.print("f = {}\n", .{f}),
    }
}
実行じっこう結果けっか
@as(Tag, tu) ⇒ Tag.char 
ch = C
タグの enum と、それを使つかうタグ付つきunionのメンバー集合しゅうごうは一致いっちしていないとエラーになります。
タグ付つきunionを式しきとするswitch式しきでは、バターンでタグのメンバーを網羅もうらしている必要ひつようがあります（網羅もうら性せいの検証けんしょうが行おこなえます。ただし _ や else をパターン使つかうと台無だいなし）。
匿名とくめいenum版ばんタグ付つきunion
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const TaggedUnion = union(enum) {
    char: u8,
    int: i64,
    float: f64,
};

pub fn main() !void {
    var tu = TaggedUnion{ .char = 'C' };
    try stdout.print("@tagName(tu) ⇒ {s}\n", .{@tagName(tu)});
    switch (tu) {
        .char => |ch| try stdout.print("ch = {c}\n", .{ch}),
        .int => |i| try stdout.print("i = {}\n", .{i}),
        .float => |f| try stdout.print("f = {}\n", .{f}),
    }
}
匿名とくめいenum版ばんタグ付つきunionは、enum のメンバーと union のメンバーの名前なまえを一致いっちさせる手間てまが不要ふようです。
他方たほう、（unionのメンバーでなく）enum のメンバーに値ねを与あたえたいときは、実体じったい化かしたタグをつか合あう必要ひつようがあります。

構文こうぶん木きを考かんがえてみましょう。Cで実装じっそうするとノードの種別しゅべつと種別しゅべつごとのペイロードの共用きょうよう体たいになります。Zigではこれを一般いっぱん化かしてタグ付つきunion１ひとつで実装じっそうすることが出来できます。 タグ付つきunionを使つかうと網羅もうら性せいの保証ほしょうもでき、多おおくの特性とくせいをメソッドとして記述きじゅつできます。たとえばキーワードや演算えんざん子こを追加ついかした場合ばあい、対応たいおうするswitchのパターンがないとエラーになりコンパイル時じに事前じぜんに変更へんこう必要ひつよう箇所かしょを確認かくにんできます。

switch式しきでタグ付つきunionの値ねの変更へんこう
[編集へんしゅう]

switch式しきでタグ付つきunionのペイロードを変更へんこうするには、変数へんすう名めいの前まえに*を置おき、ポインターにします

switch式しきでタグ付つきunionの値ねの変更へんこう
const std = @import("std");
const stdout = std.io.getStdOut().writer();

const Tag = enum {
    char,
    int,
    float,
};

const TaggedUnion = union(Tag) {
    char: u8,
    int: i64,
    float: f64,
};

pub fn main() !void {
    var tu = TaggedUnion{ .int = 42 };
    try stdout.print("@as(Tag, tu) ⇒ {}\n", .{@as(Tag, tu)});
    switch (tu) {
        Tag.char => |*ch| ch.* -= 1,
        Tag.int => |*i| i.* += 10,
        Tag.float => |*f| f.* /= 1.2,
    }
    try stdout.print("tu.int ⇒ {}\n", .{tu.int});
}
実行じっこう結果けっか
@as(Tag, tu) ⇒ Tag.int 
tu.int ⇒ 52
unionのメソッド
[編集へんしゅう]

union も他たのコンテナーと同様どうようにメソッドを持もつことが出来できます。

unionのメソッド
const std = @import("std");
const stdout = std.io.getStdOut().writer();
const signbit = std.math.signbit;

const Number = union(enum) {
    Int: i32,
    Float: f32,
    const Self = @This();

    // 共用きょうよう体たいにメソッドを追加ついか
    pub fn isPositive(self: Self) bool {
        return switch (self) {
            .Int => |value| value > 0,
            .Float => |value| !signbit(value),
        };
    }
};

pub fn main() !void {
    const i = Number{ .Int = 42 };
    const f = Number{ .Float = -4.82 };

    try stdout.print("i.isPositive() = {}\n", .{i.isPositive()});
    try stdout.print("f.isPositive() = {}\n", .{f.isPositive()}); 
}
実行じっこう結果けっか
i.isPositive() = true
f.isPositive() = false

このコードは、ZigのUnionにメソッドを追加ついかし、そのメソッドを使用しようして共用きょうよう体たいの値ねを操作そうさする方法ほうほうを示しめしています。また、浮動ふどう小数点しょうすうてん数すうの場合ばあいには、std.math.signbit を使用しようして符号ふごうを判定はんていしています。

まず、Number というUnionが定義ていぎされています。このUnionは、Int フィールドと Float フィールドを持もち、それぞれ整数せいすう型がたと浮動ふどう小数点しょうすうてん数すう型がたの値ねを保持ほじします。また、const Self = @This() を使用しようして、メソッド内ないで共用きょうよう体たいの型かたを参照さんしょうできるようにしています。

次つぎに、共用きょうよう体たいに isPositive メソッドが追加ついかされています。このメソッドは、共用きょうよう体たいが保持ほじする値ねが正せいの値ねかどうかを判定はんていします。整数せいすう型がたの場合ばあいは、単純たんじゅんに値ねが0より大おおきいかどうかを確認かくにんしています。浮動ふどう小数点しょうすうてん数すう型がたの場合ばあいは、std.math.signbit を使用しようして、値ねの符号ふごうを判定はんていしています。符号ふごうが正せいの場合ばあいは、値ねが正せいの数かずであると判断はんだんします。

最後さいごに、main 関数かんすうでは、整数せいすうと浮動ふどう小数点しょうすうてん数すうの共用きょうよう体たいを作成さくせいし、それぞれの isPositive メソッドを呼よび出だして、共用きょうよう体たいが保持ほじする値ねが正せいの値ねかどうかを確認かくにんしています。結果けっかは標準ひょうじゅん出力しゅつりょくに出力しゅつりょくされます。

実行じっこう結果けっかでは、整数せいすうが正せいの値ねであり、浮動ふどう小数点しょうすうてん数すうが負まけの値ねであるため、"i.isPositive() = true" と "f.isPositive() = false" というメッセージが表示ひょうじされます。

コードショーケース
[編集へんしゅう]
const std = @import("std");
const testing = std.testing;
const expect = testing.expect;

// Bare Unionの定義ていぎ
const Payload = union {
    int: i64,
    float: f64,
    boolean: bool,
};

// Bare Unionの使用しよう例れい
test "Bare Union" {
    var payload = Payload{ .int = 1234 };
    try expect(payload.int == 1234);
}

// Tagged Unionの定義ていぎ
const ComplexTypeTag = enum {
    ok,
    not_ok,
};
const ComplexType = union(ComplexTypeTag) {
    ok: u8,
    not_ok: void,
};

// Tagged Unionの使用しよう例れい
test "Tagged Union" {
    const c = ComplexType{ .ok = 42 };
    try expect(@as(ComplexTypeTag, c) == ComplexTypeTag.ok);

    try switch (c) {
        ComplexTypeTag.ok => |value| expect(value == 42),
        ComplexTypeTag.not_ok => unreachable,
    };
}

// Unionにメソッドを追加ついかする
const Variant = union(enum) {
    int: i32,
    boolean: bool,
    none,

    fn truthy(self: Variant) bool {
        return switch (self) {
            Variant.int => |x_int| x_int != 0,
            Variant.boolean => |x_bool| x_bool,
            Variant.none => false,
        };
    }
};

// Unionのメソッドの使用しよう例れい
test "Union Method" {
    var v1 = Variant{ .int = 1 };
    var v2 = Variant{ .boolean = false };

    try expect(v1.truthy());
    try expect(!v2.truthy());
}

// @tagNameを使用しようしたEnumの値ねの表示ひょうじ
const Small2 = union(enum) {
    a: i32,
    b: bool,
    c: u8,
};

// @tagNameの使用しよう例れい
test "@tagName" {
    try expect(std.mem.eql(u8, @tagName(Small2.a), "a"));
}

// 匿名とくめいUnionリテラルの初期しょき化か
const Number = union {
    int: i32,
    float: f64,
};

// 匿名とくめいUnionリテラルの使用しよう例れい
test "Anonymous Union Literal Syntax" {
    const i: Number = .{ .int = 42 };
    const f = makeNumber();
    try expect(i.int == 42);
    try expect(f.float == 12.34);
}

fn makeNumber() Number {
    return .{ .float = 12.34 }; 
}
実行じっこう結果けっか
1/5 test.Bare Union... OK 
2/5 test.Tagged Union... OK 
3/5 test.Union Method... OK 
4/5 test.@tagName... OK 
5/5 test.Anonymous Union Literal Syntax... OK 
All 5 tests passed.

opaque

[編集へんしゅう]

Zigのopaqueは、サイズとアライメントが不明ふめい（ただしゼロではない）な新あたらしい型かたを宣言せんげんします。struct、union、enumと同様どうように、宣言せんげんを含ふくめることができます。

これは、構造こうぞうの詳細しょうさいを公開こうかいしないCコードとやり取とりする際さいの型かた安全あんぜん性せいのために一般いっぱん的てきに使用しようされます。例たとえば： 

const Derp = opaque {};
const Wat = opaque {};

extern fn bar(d: *Derp) void;
fn foo(w: *Wat) callconv(.C) void {
    bar(w);
}

test "call foo" {
    foo(undefined);
}

opaqueを使つかうと、foo関数かんすう内ないでbar関数かんすうを呼よび出だす際さいに型かたの安全あんぜん性せいが保証ほしょうされます。

ブロック

[編集へんしゅう]

ブロック（Blocks）は、プログラム内ないで複数ふくすうの文ぶんをグループ化かする構造こうぞうで、主おもに変数へんすうのスコープを制限せいげんし、可読かどく性せいを向上こうじょうさせます。ブロック内ないで宣言せんげんされた変数へんすうは、そのブロックの外部がいぶからはアクセスできず、名前なまえの衝突しょうとつを防ふせぎます。また、条件じょうけん分岐ぶんきやループの本体ほんたいとして使用しようされ、制御せいぎょフローを明確めいかくにします。さらに、ラベル付つきブロックではbreak文ぶんを使つかって値ねを返かえしたり、ブロックから脱出だっしゅつしたりすることができます。空そらのブロックはプログラムの構造こうぞうを整理せいりするために使用しようされ、有効ゆうこうな構造こうぞう化か要素ようそとして機能きのうします。ブロックはコードの構造こうぞう化かに不可欠ふかけつであり、プログラムの理解りかいと保守ほしゅ性せいを向上こうじょうさせます。

構文こうぶん(EBNF)
block = "{" statement* "}"

statement = "comptime"? var-decl
          | "comptime" block-expr-statement
          | "nosuspend" block-expr-statement
          | "suspend" block-expr-statement
          | "defer" block-expr-statement
          | "errdefer" pay-load? block-expr-statement
          | if-statement
          | labeled-statement
          | switch-expr 
          | AssignExpr ";"
[21]

ブロックの値ね

[編集へんしゅう]

ブロックは式しきです。ラベルを付つけると、break はブロックから値ねを返かえすために使つかうことができます。 

const stdout = @import("std").io.getStdOut().writer();

pub fn main() !void {
    var y: i32 = 123;
    const x = blk: {
        y += 1;
        break :blk y + 2;
    }; 
    try stdout.print("x = {}, y = {}\n", .{x, y});
}
実行じっこう結果けっか
x = 126, y = 124
ラベル blk は、任意にんいの識別子しきべつしに置換おきかえられますが、慣習かんしゅうとして blk がよく用もちいられます。
「ラベル付つきwhile」および「ラベル付つきfor」も参照さんしょう

シャドーイング

[編集へんしゅう]

識別子しきべつしは、同おなじ名前なまえを使用しようして他たの識別子しきべつしを "隠かくす"ことは決けっして許ゆるされません。 コンパイラーは、外部がいぶスコープで既すでに使つかわれている識別子しきべつしを、ブロック内ないで使つかうとエラーにします。

このため、Zigのコードを読よむときには、その識別子しきべつしが定義ていぎされたスコープ内ないでは常つねに同おなじ意味いみであることを確認かくにんすることができます。ただし、スコープが分わかれている場合ばあい（入いれ子こ関係かんけいにない場合ばあい）には同おなじ名前なまえを使用しようすることができます。

defer

[編集へんしゅう]

defer は、スコープを抜ぬけるときに実行じっこうされる式しきまたはブロックを登録とうろくします[56]。 複数ふくすうの defer 文ぶんで登録とうろくされた場合ばあい、登録とうろくされた逆ぎゃくの順序じゅんじょに実行じっこうされます。 

const std = @import("std");
const stdout = std.io.getStdOut().writer();

fn basic_example() !usize {
    var x: usize = 0;

    {
        defer x = 123;
        x = 0;
        try stdout.print("@small block: x = {}\n", .{x});
    }
    try stdout.print("@function block: x = {}\n", .{x});

    x = 5;
    return x;
}

fn multiple_example() !void {
    try stdout.writeAll("multiple_example(): ");

    defer {
        try stdout.writeAll("1 ");
    }
    defer {
        try stdout.writeAll("2 ");
    }
    if (false) {
        // defer 自身じしんが一いち度ども実行じっこうされない場合ばあいは、実行じっこうされません。
        defer {
            try stdout.writeAll("3 ");
        }
    }
}

pub fn main() !void {
    try stdout.print("basic_example()  = {}\n", .{basic_example()});
    multiple_example();
}
実行じっこう結果けっか
@small block: x = 0 
@function block: x = 123 
basic_example()  = 5 
multiple_example(): 2 1
「errdefer」も参照さんしょう

errdefer

[編集へんしゅう]

errdefer は、エラーが原因げんいんでスコープを抜ぬけるときに実行じっこうされる式しきまたはブロックを登録とうろくします[57]。 複数ふくすうの errdefer 文ぶんで登録とうろくされた場合ばあい、登録とうろくされた逆ぎゃくの順序じゅんじょに実行じっこうされます。 errdefer は、スコープを抜ぬける原因げんいんとなったエラーコードをキャプチャーできます。 

    errdefer |err| {
        std.debug.print("the error is {s}\n", .{@errorName(err)}); 
    }
「defer」も参照さんしょう

キャスト

[編集へんしゅう]

Zigでは、キャスティングは一ひとつの型かたから別べつの型かたへの明示めいじ的てきな変換へんかんを指さします。この機能きのうは、異ことなる型かた間あいだでのデータの変換へんかんや操作そうさを可能かのうにし、プログラムの柔軟じゅうなん性せいを高たかめます。Zigにはさまざまな種類しゅるいのキャストがあり、それぞれが特定とくていの目的もくてきに使用しようされます[58]。

以下いかでは、Zigのキャスティングについて詳細しょうさいに説明せつめいします。

  1. 型かたの強制きょうせい変換へんかん (Explicit Casts):
    • Zigでは、@bitCast、@alignCast、@enumFromIntなどのビルトイン関数かんすうを使用しようして、明示めいじ的てきなキャストを実行じっこうします。
    • これらのキャストは、安全あんぜんなものとそうでないものがあります。一部いちぶのキャストはランタイムでの動作どうさを変更へんこうせず、他たのキャストは言語げんごレベルのアサーションを実行じっこうします。
    • たとえば、@intCastは整数せいすう型がた間あいだでの変換へんかんを行おこないますが、ビットの丸まるめは行おこないません。これに対たいして、@floatCastは浮動ふどう小数点しょうすうてん数すうをより小ちいさいサイズの浮動ふどう小数点しょうすうてん数すうに変換へんかんしますが、精度せいどが失うしなわれる可能かのう性せいがあります。
  2. 型かたの解決かいけつ (Peer Type Resolution):
    • switch、if、while、forなどの文脈ぶんみゃくで複数ふくすうの型かたが存在そんざいする場合ばあい、Zigはそれらの型かたを解決かいけつします。これにより、すべての型かたが変換へんかん可能かのうな型かたが選択せんたくされます。
    • たとえば、switch文ぶん内ないでi8とi16の変数へんすうを追加ついかすると、その結果けっかの型かたはi16になります。これにより、型かたが一貫いっかん性せいを持もち、予測よそく可能かのうな動作どうさが実現じつげんされます。

これらのキャスト機能きのうは、Zigの柔軟じゅうなん性せいと安全あんぜん性せいを向上こうじょうさせ、異ことなる型かた間あいだでのデータの変換へんかんや操作そうさを容易よういにします。

  1. Type Coercion (型かた変換へんかん):
    • Type Coercionは、一ひとつの型かたが期待きたいされる場面ばめんで、異ことなる型かたが提供ていきょうされた場合ばあいに発生はっせいします。
    • test_type_coercion.zigでは、変数へんすう宣言せんげんや関数かんすう呼よび出だし時じに型かた変換へんかんが示しめされています。
  2. Stricter Qualification (厳格げんかくな修飾しゅうしょく):
    • 同おなじランタイム表現ひょうげんを持もつ値ねを、修飾しゅうしょく子この厳密げんみつさを増ふやすためにキャストすることができます。
  3. Integer and Float Widening (整数せいすうおよび浮動ふどう小数点しょうすうてんの拡張かくちょう):
    • 整数せいすうおよび浮動ふどう小数点しょうすうてんの型かたが、それを表現ひょうげんできるより大おおきな型かたに自動的じどうてきに変換へんかんされます。
  4. Float to Int (浮動ふどう小数点しょうすうてんから整数せいすうへの変換へんかん):
    • 浮動ふどう小数点しょうすうてん数すうを整数せいすうにキャストすることは曖昧あいまいであり、コンパイラエラーが発生はっせいします。
  5. Slices, Arrays and Pointers (スライス、配列はいれつ、ポインタの変換へんかん):
    • スライス、配列はいれつ、ポインタの間あいだでの相互そうご変換へんかんが示しめされています。
  6. Optionals (オプショナル):
    • オプショナル型がたのペイロードやnull値ちが、オプショナル型がた自体じたいにキャストされることが示しめされています。
  7. Error Unions (エラーユニオン):
    • エラーコードやエラーセットがエラーユニオン型がたにキャストされることが示しめされています。
  8. Compile-Time Known Numbers (コンパイル時じに既知きちの数値すうち):
    • 数値すうちが宛先あてさき型がたで表現ひょうげん可能かのうである場合ばあいにのみ、キャストが行おこなわれることが示しめされています。
  9. Unions and Enums (ユニオンと列挙れっきょ型がた):
    • タグ付つきユニオンが列挙れっきょ型がたに、そして列挙れっきょ型がたがタグ付つきユニオンにキャストされることが示しめされています。
  10. Tuples to Arrays (タプルから配列はいれつへの変換へんかん):
    • 同おなじ型がたのフィールドを持もつタプルは、配列はいれつにキャストすることができます。
  11. Explicit Casts (明示めいじ的てきなキャスト):
    • @bitCast、@alignCast、@enumFromIntなどのビルトイン関数かんすうを使用しようして明示めいじ的てきなキャストが行おこなわれます。
  12. Peer Type Resolution (ピア型がた解決かいけつ):
    • Peer Type Resolutionは、スイッチ式しきやif式しきなどの複数ふくすうのオペランド型がたが与あたえられた場合ばあいに使用しようされます。

これらの機能きのうは、Zig言語げんごにおいて型かたの柔軟じゅうなんな操作そうさと安全あんぜんな変換へんかんを可能かのうにし、コードの表現ひょうげん力りょくを高たかめます。

型かた強制きょうせい

[編集へんしゅう]

Zigにおける型かた強制きょうせい（Type Coercion）は、コンパイラが型かたの不一致ふいっちを解消かいしょうするために行おこなう自動的じどうてきな型かた変換へんかんのプロセスを指さします。Zigでは、いくつかの場面ばめんで型かた強制きょうせいが行おこなわれます。

  1. 変数へんすうの代入だいにゅう: 変数へんすうがある型かたで宣言せんげんされている場合ばあい、その変数へんすうに代入だいにゅうされる値ねが宣言せんげんされた型かたと異ことなる場合ばあい、Zigは型かた強制きょうせいを行おこないます。ただし、この変換へんかんは安全あんぜんな場合ばあいに限かぎります。たとえば、整数せいすう型がたから浮動ふどう小数点しょうすうてん数すう型がたへの変換へんかんは安全あんぜんですが、逆ぎゃくの変換へんかんは損失そんしつが発生はっせいする可能かのう性せいがあるため、コンパイラは警告けいこくやエラーを生成せいせいすることがあります。
  2. 関数かんすう呼よび出だし時じの引数ひきすうの型かたの一致いっち: 関数かんすうが特定とくていの型かたの引数ひきすうを受うけ取とる場合ばあい、関数かんすう呼よび出だし時じに与あたえられた引数ひきすうの型かたが完全かんぜんに一致いっちしない場合ばあい、Zigは適切てきせつな型かたに変換へんかんします。これにより、型かたの不一致ふいっちによるエラーが回避かいひされます。
  3. 演算えんざん子この使用しよう: 演算えんざん子こを使用しようする際さいに、オペランドの型かたが一致いっちしない場合ばあい、Zigは適切てきせつな型かたに変換へんかんして演算えんざんを行おこないます。たとえば、整数せいすう型がたと浮動ふどう小数点しょうすうてん数すう型がたの演算えんざんを行おこなう場合ばあい、整数せいすう型がたは浮動ふどう小数点しょうすうてん数すう型がたに変換へんかんされます。
  4. 明示めいじ的てきな型かた変換へんかん: プログラマが明示めいじ的てきに型かたを変換へんかんしたい場合ばあい、@asや@intCastなどの組くみ込こみ関数かんすうを使用しようして、型かた変換へんかんを行おこなうことができます。これにより、プログラマが意図いと的てきに型かた変換へんかんを行おこなうことができます。

Zigの型かた強制きょうせいは、安全あんぜんな変換へんかんのみを行おこなうことを目指めざしており、潜在せんざい的てきなデータの損失そんしつや不正確ふせいかくな結果けっかを防ふせぐために注意深ちゅういぶかく設計せっけいされています。

明示めいじ的てきキャスト

[編集へんしゅう]

明示めいじ的てきキャスト（Explicit Casts）は、コンパイラに対たいして特定とくていの型かたへの明示めいじ的てきな変換へんかんを指示しじする手段しゅだんです。これは、コンパイラによって自動的じどうてきに処理しょりされる型かた強制きょうせいとは異ことなり、プログラマが意図いと的てきに型かたの変換へんかんを指定していする場合ばあいに使用しようされます。Zigでは、さまざまな種類しゅるいの明示めいじ的てきキャストが提供ていきょうされています。

以下いかは、Zigで使用しようできる主おもな明示めいじ的てきキャストの例れいです：

  1. @bitCast: ビットレベルでの変換へんかんを行おこない、型かたのビット表現ひょうげんを維持いじします。このキャストは非常ひじょうに低ていレベルであり、注意ちゅういが必要ひつようです。
  2. @alignCast: ポインタのアライメントを増ふやします。より厳格げんかくなアライメントが必要ひつような場合ばあいに使用しようされます。
  3. @enumFromInt: 整数せいすう値ちから列挙れっきょ型がたの値ねを取得しゅとくします。列挙れっきょ型がたの値ねを整数せいすう値ちに変換へんかんする逆ぎゃくの操作そうさは、自動的じどうてきな型かた強制きょうせいで行おこなわれます。
  4. @errorFromInt: 整数せいすう値ちからエラーコードを取得しゅとくします。
  5. @errorCast: より小ちいさなエラーセットに変換へんかんします。
  6. @floatCast: より大おおきな浮動ふどう小数点しょうすうてん数すう型がたから小ちいさな浮動ふどう小数点しょうすうてん数すう型がたに変換へんかんします。
  7. @floatFromInt: 整数せいすう値ちから浮動ふどう小数点しょうすうてん数値すうちに変換へんかんします。
  8. @intCast: 整数せいすう型がた間あいだでの変換へんかんを行おこないます。
  9. @intFromBool: 真偽しんぎ値ちを整数せいすう値ちに変換へんかんします。
  10. @intFromEnum: 列挙れっきょ型がたのタグ値ちを整数せいすう値ちとして取得しゅとくします。
  11. @intFromError: エラーコードを整数せいすう値ちとして取得しゅとくします。
  12. @intFromFloat: 浮動ふどう小数点しょうすうてん数値すうちの整数せいすう部分ぶぶんを取得しゅとくします。
  13. @intFromPtr: ポインタのアドレスを整数せいすう値ちとして取得しゅとくします。
  14. @ptrFromInt: 整数せいすう値ちをポインタのアドレスに変換へんかんします。
  15. @ptrCast: ポインタ型がた間あいだの変換へんかんを行おこないます。
  16. @truncate: 整数せいすう型がた間あいだでの変換へんかんを行おこない、ビットを切きり捨すてます。

これらの明示めいじ的てきなキャストは、プログラマがコンパイラに対たいして特定とくていの型かた変換へんかんを指定していする必要ひつようがある場合ばあいに使用しようされます。ただし、使用しようする際さいには注意ちゅういが必要ひつようであり、不適切ふてきせつなキャストがプログラムの安全あんぜん性せいや正確せいかく性せいに影響えいきょうを与あたえる可能かのう性せいがあるため、慎重しんちょうに検討けんとうする必要ひつようがあります。

ピア型がた解決かいけつ

[編集へんしゅう]

Zigのピア型がた解決かいけつ（Peer Type Resolution）は、複数ふくすうのオペランドの型かたから、それらが共通きょうつうして受うけ入いれ可能かのうな型かたを決定けっていするプロセスです。このプロセスは、通常つうじょう、switchやifなどの条件じょうけん式しき、またはforやwhileなどのループの条件じょうけん式しきで使用しようされます。ピア型がた解決かいけつは、これらの式しきで使用しようされる型かたを決定けっていするために、与あたえられた複数ふくすうの型かたの間あいだで最もっとも適切てきせつな共通きょうつう型がたを見みつけることを目的もくてきとしています[59]。

具体ぐたい的てきには、ピア型がた解決かいけつは以下いかの場面ばめんで発生はっせいします：

  • switch 式しき
  • if 式しき
  • while 式しき
  • for 式しき
  • ブロック内ないの複数ふくすうの break 文ぶん
  • 一部いちぶのバイナリ演算えんざん

ピア型がた解決かいけつでは、複数ふくすうの型かたの間あいだで共通きょうつうの型かたを見みつけるために、次つぎのようなルールが適用てきようされます：

  • 整数せいすうの場合ばあい、最大さいだいのビット幅はばを持もつ整数せいすう型がたが選択せんたくされます。
  • 浮動ふどう小数点しょうすうてん数すうの場合ばあい、最もっとも精度せいどの高たかい浮動ふどう小数点しょうすうてん数すう型がたが選択せんたくされます。
  • スライスや配列はいれつなどのコンテナ型がたの場合ばあい、要素ようその型かたが共通きょうつうの場合ばあいに選択せんたくされます。
  • オプショナル型がたの場合ばあい、共通きょうつうの基底きてい型がたが選択せんたくされます。
  • ポインタ型がたの場合ばあい、共通きょうつうのポインタ型がたが選択せんたくされます。

これにより、Zigのコンパイラは、異ことなる型かたを持もつ複数ふくすうのオペランドに対たいして最もっとも適切てきせつな共通きょうつうの型かたを決定けっていし、型かたの整合せいごう性せいを確保かくほします。

ゼロビット型がた

[編集へんしゅう]

ゼロビット型がた( Zero Bit Types )、実際じっさいにはデータを保持ほじしない型かたのことを指さします。これらの型かたは、メモリ内ないの領域りょういきを占有せんゆうしないため、サイズがゼロビットです[60]。

Zigでは、ゼロビット型がたは主おもに型かたシステムの柔軟じゅうなん性せいと型かた安全あんぜん性せいを高たかめるために使用しようされます。これらの型かたは、実行じっこう時じのメモリ使用しよう量りょうやパフォーマンスには影響えいきょうしませんが、コードの明確めいかくさと保守ほしゅ性せいを向上こうじょうさせるのに役立やくだちます。

アセンブリ言語げんごとの連携れんけい

[編集へんしゅう]

[TODO:所謂いわゆるインラインアセンラ]

atomic

[編集へんしゅう]

非同期ひどうき関数かんすう

[編集へんしゅう]

Zigでは、キーワード async を伴ともなって関数かんすうまたはメソッドを呼よび出だすと、その関数かんすうまたはメソッドの処理しょりを休止きゅうしし再開さいかいすることができます。

async.zig
const std = @import("std");

var frame: anyframe = undefined;

pub fn main() !void {
    try println("begin main");
    _ = async func();
    try println("resume func");
    resume frame;
    try println("end main");
}

fn func() !void {
    try println("begin func");
    frame = @frame();
    suspend {}
    try println("end func");
}

fn println(s: []const u8) !void {
    try std.io.getStdOut().writer().print("{s}\n",.{s});
}
実行じっこう結果けっか
begin main
begin func
resume func
end func
end main

unreachable

[編集へんしゅう]

Zigのunreachableは、制御せいぎょフローが特定とくていの位置いちに到達とうたつしないことを明示めいじするために使用しようされます。具体ぐたい的てきには、その部分ぶぶんに到達とうたつすることがプログラムの不正ふせいな動作どうさであることを表明ひょうめいします。 

if (false) {
    unreachable;
}

Debug と ReleaseSafe モード、および zig test を使用しようする場合ばあい、unreachable は到達とうたつ不能ふのうなコードに到達とうたつしたメッセージとともに panic への呼よび出だしを出だします[61]。

ReleaseFast モードでは、オプティマイザーは到達とうたつ不能ふのうなコードは決けっしてヒットしないという仮定かていを使用しようして最適さいてき化かを実行じっこうします。しかし、ReleaseFastモードでもzigテストはunreachableをpanicへの呼出よびだしとして出力しゅつりょくします。

「テスト」、「ビルドモード」、および「comptime」も参照さんしょう

コンパイル時じ

[編集へんしゅう]

unreachableの型かたはnoreturnです[62]。 ＠TypeOf(unreachable)はコンパイルに失敗しっぱいします。 unreachable式しきはコンパイルエラーになるからです。

noreturn型がた

[編集へんしゅう]

noreturnは、つぎ文ぶんの型かたです[63]。

  • break
  • continue
  • return
  • unreachable
  • while (true) {}

if節ぶしやswitchの分岐ぶんき先さき( prongs )など、型かたを一緒いっしょに解決かいけつする場合ばあい、noreturn型がたは他たのすべての型かたと互換ごかん性せいがあります。

組込くみこみ関数かんすう

[編集へんしゅう]

組込くみこみ関数かんすう( Builtin Functions )はコンパイラによって提供ていきょうされ、接頭せっとう辞じに @ が付つけられます。 パラメーターについての comptime キーワードは、そのパラメーターがコンパイル時じに既知きちである必要ひつようがあることを意味いみします[64]。

組込くみこみ関数かんすう一覧いちらん
関数かんすうプロトタイプ 種別しゅべつ 説明せつめい 
@addrSpaceCast(ptr: anytype) anytype
[65] 		キャスト ポインターを1つのアドレス空間くうかんから別べつのアドレス空間くうかんに変換へんかんします。新あたらしいアドレス空間くうかんは結果けっかの型かたに基もとづいて推論すいろんされます。現在げんざいのターゲットとアドレス空間くうかんに応おうじて、このキャストは無効むこう、複雑ふくざつな操作そうさ、または違法いほうである場合ばあいがあります。キャストが適法てきほうである場合ばあい、結果けっかのポインターはポインターオペランドと同おなじメモリー位置いちを指さします。同おなじアドレス空間くうかん間あいだでのポインターのキャストは常つねに有効ゆうこうです。 
@addWithOverflow(a: anytype, b: anytype) struct { @TypeOf(a, b), u1 }
[66] 		数値すうち演算えんざん a + b を実行じっこうし、結果けっかと可能かのうなオーバーフロービットを持もつタプルを返かえします。 
@alignCast(ptr: anytype) anytype
[67] 		アライメント ptr は *T, ?*T, または []T のいずれかです。ポインターのアライメントを変更へんこうします。使用しようするアライメントは結果けっかの型かたに基もとづいて推論すいろんされます。生成せいせいされたコードには、ポインターが約束やくそくされたようにアラインされていることを確認かくにんするためのポインターアライメント安全あんぜん検査けんさが追加ついかされます。 
@alignOf(comptime T: type) comptime_int
[68] 		アライメント この関数かんすうは、現在げんざいのターゲットがCのABIに適合てきごうするために、この型かたがアライメントされるべきバイト数すうを返かえします。ポインターの子供こどもの型かたがこのアライメントを持もっている場合ばあい、アライメントを省略しょうりゃくすることができます。 
@as(comptime T: type, expression) T
[69] 		キャスト 型かた強制きょうせいを行おこないます。このキャストは、変換へんかんが曖昧あいまいでなく安全あんぜんである場合ばあいに許可きょかされ、可能かのうな限かぎり、型かた間あいだの変換へんかんに好このましい方法ほうほうとされています。 
@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: AtomicOrder) T
[70] 		不可分ふかぶん操作そうさ ポインターをアトミックにデリファレンスしてその値ねを返かえします。 T は、ポインター、bool、整数せいすう、浮動ふどう小数点しょうすうてん数すうあるいは enum でなければなりません。 
@atomicRmw(comptime T: type, ptr: *T, comptime op: AtomicRmwOp, operand: T, comptime ordering: AtomicOrder) T
[71] 		不可分ふかぶん操作そうさ メモリーをアトミックに変更へんこうした後のち、以前いぜんの値ねを返かえします。 T は、ポインター、bool、整数せいすう、浮動ふどう小数点しょうすうてん数すうあるいは enum でなければなりません。 
@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: AtomicOrder) void
[72] 		不可分ふかぶん操作そうさ 値ねをアトミックに保存ほぞんします。 T は、ポインター、bool、整数せいすう、浮動ふどう小数点しょうすうてん数すうあるいは enum でなければなりません。 
@bitCast(value: anytype) anytype
[73] 		キャスト 1つの型かたの値ねを別べつの型かたに変換へんかんします。戻もどり型がたは推論すいろんされた結果けっか型がたです。 
@bitOffsetOf(comptime T: type, comptime field_name: []const u8) comptime_int
[74] 		オフセット フィールドのビットオフセットを、それを含ふくむ struct からの相対そうたい値ちで返かえします。 
@bitSizeOf(comptime T: type) comptime_int
[75] 		特性とくせい 型かたがパックされたstruct/unionのフィールドであった場合ばあいに、Tをメモリーに格納かくのうするために必要ひつようなビット数すうを返かえします。 
@breakpoint()
[76] 		デバッグ プラットフォーム固有こゆうのデバッグトラップ命令めいれいを挿入そうにゅうし、デバッガがそこでブレークするようにします。 
@mulAdd(comptime T: type, a: T, b: T, c: T) T
[77] 		数値すうち演算えんざん 積せき和わ演算えんざん（Fused multiply-add）を実行じっこうします。 
@byteSwap(operand: anytype) T
[78] 		キャスト オペランドのバイト順序じゅんじょを逆転ぎゃくてんさせます。 
@bitReverse(integer: anytype) T
[79] 		キャスト 整数せいすう値ちのビットパターンを逆転ぎゃくてんさせます。 
@offsetOf(comptime T: type, comptime field_name: []const u8) comptime_int
[80] 		オフセット フィールドのバイトオフセットを、それを含ふくむ struct からの相対そうたい値ちで返かえします。 
@call(modifier: std.builtin.CallModifier, function: anytype, args: anytype) anytype
[81] 		呼よび出だし 指定していされた関数かんすうを呼よび出だします。 
@cDefine(comptime name: []const u8, value) void
[82] 		マクロ定義ていぎ Cマクロを定義ていぎします。 
@cImport(expression) type
[83] 		C インタフェース この関数かんすうは C コードを解析かいせきし、関数かんすう、型かた、変数へんすう、および互換ごかん性せいのあるマクロ定義ていぎを新あたらしい空そらの構造こうぞう体型たいけいにインポートし、その型かたを返かえします。expression はコンパイル時じに解釈かいしゃくされます。この式内しきないで、@cInclude、@cDefine、@cUndef の組くみ込こみ関数かんすうが動作どうさし、一時いちじバッファに追加ついかされ、それが C コードとして解析かいせきされます。通常つうじょう、アプリケーション全体ぜんたいで 1 つの @cImport のみを持もつべきです。これにより、コンパイラが複ふく数すう回かい clang を起動きどうするのを防ふせぎ、インライン関数かんすうが重複じゅうふくしないようにします。複数ふくすうの @cImport 式しきが必要ひつような理由りゆうは次つぎのとおりです：
  1. シンボルの衝突しょうとつを回避かいひするため（例れい：foo.h と bar.h がともに CONNECTION_COUNT を #define している場合ばあい）
  2. 異ことなるプリプロセッサの定義ていぎで C コードを解析かいせきするため
@cInclude(comptime path: []const u8) void
[84] 		C インタフェース この関数かんすうは @cImport 内ないでのみ発生はっせいします。これは c_import 一いち時じバッファに #include <$path>\n を追加ついかします。 
@clz(operand: anytype) anytype
[85] 		キャスト 整数せいすうの最さい上位じょういビット（ビッグエンディアンでの先頭せんとうビット）からのゼロの数かずを数かぞえます。 
@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T
[86] 		不可分ふかぶん操作そうさ 強力きょうりょくな原子げんし比較ひかく交換こうかん操作そうさを実行じっこうし、現在げんざいの値ねが指定していされた期待きたい値ちでない場合ばあいはnullを返かえします。 
@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T
[87] 		不可分ふかぶん操作そうさ 弱よわい原子げんし比較ひかく交換こうかん操作そうさを実行じっこうし、現在げんざいの値ねが指定していされた期待きたい値ちでない場合ばあいはnullを返かえします。 
@compileError(comptime msg: []const u8) noreturn
[88] 		コンパイル時じエラー 意味いみ解析かいせきされると、メッセージmsgを持もつコンパイルエラーが発生はっせいします。 
@compileLog(args: ...) void
[89] 		コンパイルログ 引数ひきすうをコンパイル時じに出力しゅつりょくします。 
@constCast(value: anytype) DestType
[90] 		キャスト ポインターからconst修飾しゅうしょく子こを削除さくじょします。 
@ctz(operand: anytype) anytype
[91] 		キャスト 整数せいすうの最下位さいかいビット（ビッグエンディアンでの末尾まつびビット）からのゼロの数かずを数かぞえます。 
@cUndef(comptime name: []const u8) void
[92] 		マクロ定義ていぎ解除かいじょ Cマクロを無効むこうにします。 
@cVaArg(operand: *std.builtin.VaList, comptime T: type) T
[93] 		可変かへん引数ひきすう Cマクロva_argを実装じっそうします。 
@cVaCopy(src: *std.builtin.VaList) std.builtin.VaList
[94] 		可変かへん引数ひきすう Cマクロva_copyを実装じっそうします。 
@cVaEnd(src: *std.builtin.VaList) void
[95] 		可変かへん引数ひきすう Cマクロva_endを実装じっそうします。 
@cVaStart() std.builtin.VaList
[96] 		可変かへん引数ひきすう Cマクロva_startを実装じっそうします。 
@divExact(numerator: T, denominator: T) T
[97] 		数値すうち演算えんざん 完全かんぜんな除算じょざん。デノミネーター != 0 であり、@divTrunc(numerator, denominator) * denominator == numerator を保証ほしょうする必要ひつようがあります。 
@divFloor(numerator: T, denominator: T) T
[98] 		数値すうち演算えんざん 床ゆか付つきの除算じょざん。負まけの無限むげん大だいに向むかって丸まるめます。符号ふごうなし整数せいすうの場合ばあい、分子ぶんし / 分母ぶんぼと同おなじです。 
@divTrunc(numerator: T, denominator: T) T
[99] 		数値すうち演算えんざん 切きり捨すて除算じょざん。ゼロに向むかって丸まるめます。符号ふごうなし整数せいすうの場合ばあい、分子ぶんし / 分母ぶんぼと同おなじです。 
@embedFile(comptime path: []const u8) *const [N:0]u8
[100] 		ファイル操作そうさ ファイルの内容ないようを持もつ、ヌル終端しゅうたんの固定こていサイズ配列はいれつへのコンパイル時じ定数ていすうポインターを返かえします。 
@enumFromInt(integer: anytype) anytype
[101] 		キャスト 整数せいすうを列挙れっきょ値ちに変換へんかんします。 
@errorFromInt(value: std.meta.Int(.unsigned, @bitSizeOf(anyerror))) anyerror
[102] 		キャスト エラーの整数せいすう表現ひょうげんからグローバルエラーセット型がたに変換へんかんします。 
@errorName(err: anyerror) [:0]const u8
[103] 		文字もじ列れつ操作そうさ エラーの文字もじ列れつ表現ひょうげんを返かえします。 
@errorReturnTrace() ?*builtin.StackTrace
[104] 		エラー処理しょり エラーの返がえり値ちが追跡ついせきされている場合ばあい、スタックトレースオブジェクトを返かえします。それ以外いがいの場合ばあいはnullを返かえします。 
@errorCast(value: anytype) anytype
[105] 		キャスト エラーセットまたはエラーユニオンの値ねを別べつのエラーセットに変換へんかんします。 
@export(declaration, comptime options: std.builtin.ExportOptions) void
[106] 		シンボル出力しゅつりょく 出力しゅつりょくオブジェクトファイルにシンボルを作成さくせいします。 
@extern(T: type, comptime options: std.builtin.ExternOptions) T
[107] 		外部がいぶシンボル参照さんしょう 出力しゅつりょくオブジェクトファイルに外部がいぶシンボルへの参照さんしょうを作成さくせいします。 
@fence(order: AtomicOrder) void
[108] 		同期どうき操作そうさ 発生はっせい前後ぜんこうのエッジを導入どうにゅうするために使用しようされます。 
@field(lhs: anytype, comptime field_name: []const u8) (field)
[109] 		フィールドアクセス コンパイル時じ文字もじ列れつでフィールドアクセスを実行じっこうします。 
@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8, field_ptr: *T) *ParentType
[110] 		ポインター操作そうさ フィールドへのポインターから、構造こうぞう体たいのベースポインターを返かえします。 
@floatCast(value: anytype) anytype
[111] 		キャスト 1つの浮動ふどう小数点しょうすうてん数すう型がたから別べつの浮動ふどう小数点しょうすうてん数すう型がたに変換へんかんします。 
@floatFromInt(int: anytype) anytype
[112] 		キャスト 整数せいすうを最もっとも近ちかい浮動ふどう小数点しょうすうてん数表現すうひょうげんに変換へんかんします。 
@frameAddress() usize
[113] 		デバッグ 現在げんざいのスタックフレームのベースポインターを返かえします。 
@hasDecl(comptime Container: type, comptime name: []const u8) bool
[114] 		メタ情報じょうほう コンテナに指定していされた名前なまえの宣言せんげんがあるかどうかを返かえします。 
@hasField(comptime Container: type, comptime name: []const u8) bool
[115] 		メタ情報じょうほう 構造こうぞう体たい、共用きょうよう体たい、または列挙れっきょ型がたの指定していされたフィールド名めいが存在そんざいするかどうかを返かえします。 
@import(comptime path: []const u8) type
[116]XXX 		ビルド管理かんり path に対応たいおうする Zig ファイルを見みつけ、まだ追加ついかされていない場合ばあいにビルドに追加ついかします。 
@inComptime() bool
[117] 		メタ情報じょうほう このビルトインがコンパイル時じに実行じっこうされたかどうかを返かえします。 
@intCast(int: anytype) anytype
[118] 		キャスト 数値すうちを同おなじ数値すうちとしてのみ変換へんかんします。 
@intFromBool(value: bool) u1
[119] 		キャスト true を @as(u1, 1)、false を @as(u1, 0) に変換へんかんします。 
@intFromEnum(enum_or_tagged_union: anytype) anytype
[120] 		キャスト 列挙れっきょ値ちを整数せいすうのタグ型がたに変換へんかんします。 
@intFromError(err: anytype) std.meta.Int(.unsigned, @bitSizeOf(anyerror))
[121] 		キャスト エラーをエラーの整数せいすう表現ひょうげんに変換へんかんします。 
@intFromFloat(float: anytype) anytype
[122] 		キャスト 浮動ふどう小数点しょうすうてん数すうの整数せいすう部分ぶぶんを変換へんかんします。 
@intFromPtr(value: anytype) usize
[123] 		キャスト ポインターを usize に変換へんかんします。 
@max(a: T, b: T) T
[124] 		数値すうち演算えんざん a と b の最大さいだい値ちを返かえします。 
@memcpy(noalias dest, noalias source) void
[125] 		メモリ操作そうさ メモリの領域りょういきを別べつの領域りょういきにコピーします。 
@memset(dest, elem) void
[126] 		メモリ操作そうさ メモリ領域りょういきの全ぜん要素ようそを elem に設定せっていします。 
@min(a: T, b: T) T
[127] 		数値すうち演算えんざん a と b の最小さいしょう値ちを返かえします。 
@wasmMemorySize(index: u32) u32
[128] 		メモリ操作そうさ 指定していされたインデックスの Wasm メモリのサイズを Wasm ページ単位たんいで返かえします。 
@wasmMemoryGrow(index: u32, delta: u32) i32
[129] 		メモリ操作そうさ 指定していされたインデックスの Wasm メモリのサイズを増ふやします。 
@mod(numerator: T, denominator: T) T
[130] 		数値すうち演算えんざん 剰余じょうよを返かえします。 
@mulWithOverflow(a: anytype, b: anytype) struct { @TypeOf(a, b), u1 }
[131] 		数値すうち演算えんざん オーバーフロー可能かのうな掛かけ算ざんを行おこない、結果けっかと可能かのうなオーバーフローのビットを返かえします。 
@panic(message: []const u8) noreturn
[132] 		デバッグ パニックハンドラー関数かんすうを呼よび出だします。 
@popCount(operand: anytype) anytype
[133] 		ビット操作そうさ 整数せいすうの中なかでセットされたビットの数かずを数かぞえます。 
@prefetch(ptr: anytype, comptime options: PrefetchOptions) void
[134] 		メモリアクセス プリフェッチ命令めいれいを発行はっこうします。 
@ptrCast(value: anytype) anytype
[135] 		キャスト 1つの型かたのポインターを別べつの型かたのポインターに変換へんかんします。 
@ptrFromInt(address: usize) anytype
[136] 		キャスト 整数せいすうをポインターに変換へんかんします。 
@rem(numerator: T, denominator: T) T
[137] 		数値すうち演算えんざん 剰余じょうよの計算けいさんを行おこないます。符号ふごうなし整数せいすうの場合ばあい、これは numerator % denominator と同おなじです。呼よび出だし側がわは denominator > 0 を保証ほしょうする必要ひつようがあります。それ以外いがいの場合ばあい、ランタイムセーフティチェックが有効ゆうこうになっている場合ばあい、操作そうさは除算じょざんゼロによる剰余じょうよが発生はっせいします。 
@returnAddress() usize
[138] 		デバッグ この関数かんすうは、現在げんざいの関数かんすうがリターンしたときに実行じっこうされる次つぎのマシンコード命令めいれいのアドレスを返かえします。 
@select(comptime T: type, pred: @Vector(len, bool), a: @Vector(len, T), b: @Vector(len, T)) @Vector(len, T)
[139] 		条件じょうけん付つき選択せんたく pred に基もとづいて a または b から要素ようそを選択せんたくします。pred[i] が true の場合ばあい、結果けっかの対応たいおうする要素ようそは a[i] になり、そうでなければ b[i] になります。 
@setAlignStack(comptime alignment: u29) void
[140] 		スタックアライメント 関数かんすうのスタックアライメントが少すくなくとも指定していされたバイト数すうになるように保証ほしょうします。 
@setCold(comptime is_cold: bool) void
[141] 		最適さいてき化か 現在げんざいの関数かんすうが（またはされない）まれに呼よび出だされることを最適さいてき化かプログラムに伝つたえます。この関数かんすうは関数かんすうスコープ内ないでのみ有効ゆうこうです。 
@setEvalBranchQuota(comptime new_quota: u32) void
[142] 		コンパイル時じコード コンパイル時じのコード実行じっこうが使用しようするバックワードブランチの最大さいだい数すうを増ふやします。新あたらしいクォータがデフォルトのクォータ（1000）より小ちいさい場合ばあいや、以前いぜんに明示めいじ的てきに設定せっていされたクォータよりも小ちいさい場合ばあいは、無視むしされます。 
@setFloatMode(comptime mode: FloatMode) void
[143] 		浮動ふどう小数点しょうすうてんモード 浮動ふどう小数点しょうすうてん演算えんざんの定義ていぎ方法ほうほうに関かんする現在げんざいのスコープのルールを変更へんこうします。 
@setRuntimeSafety(comptime safety_on: bool) void
[144] 		ランタイムセーフティ 関数かんすう呼よび出だしを含ふくむスコープでランタイムセーフティチェックが有効ゆうこうかどうかを設定せっていします。 
@shlExact(value: T, shift_amt: Log2T) T
[145] 		数値すうち演算えんざん 左ひだりシフト演算えんざん（<<）を実行じっこうします。符号ふごうなし整数せいすうの場合ばあい、シフトアウトされる任意にんいの1ビットがあると結果けっかは未定義みていぎです。符号ふごう付つき整数せいすうの場合ばあい、結果けっかは、結果けっかの符号ふごうビットと一致いっちしないビットがシフトアウトされた場合ばあいには未定義みていぎです。 
@shlWithOverflow(a: anytype, shift_amt: Log2T) struct { @TypeOf(a), u1 }
[146] 		数値すうち演算えんざん a << b を実行じっこうし、結果けっかとオーバーフロービットの可能かのう性せいがあるタプルを返かえします。 
@shrExact(value: T, shift_amt: Log2T) T
[147] 		数値すうち演算えんざん 右みぎシフト演算えんざん（>>）を実行じっこうします。呼よび出だし側がわは、シフトが任意にんいの1ビットをアウトさせないことを保証ほしょうします。 
@shuffle(comptime E: type, a: @Vector(a_len, E), b: @Vector(b_len, E), comptime mask: @Vector(mask_len, i32)) @Vector(mask_len, E)
[148] 		ベクトル操作そうさ マスクに基もとづいて a と b から要素ようそを選択せんたくして新あたらしいベクトルを構築こうちくします。 
@sizeOf(comptime T: type) comptime_int
[149] 		メモリ操作そうさ メモリ内ないで T を格納かくのうするために必要ひつようなバイト数すうを返かえします。 
@splat(scalar: anytype) anytype
[150] 		ベクトル操作そうさ 各かく要素ようそがスカラー値ちであるベクトルを生成せいせいします。 
@reduce(comptime op: std.builtin.ReduceOp, value: anytype) E
[151] 		ベクトル操作そうさ 指定していされた演算えんざん子こ op を使用しようして、要素ようその水平すいへいリダクションを実行じっこうしてスカラー値ち（型かたE）に変換へんかんします。 
@src() std.builtin.SourceLocation
[152] 		デバッグ 関数かんすうの名前なまえとソースコード内ないの場所ばしょを表あらわす SourceLocation 構造こうぞう体たいを返かえします。 
@sqrt(value: anytype) @TypeOf(value)
[153] 		数値すうち演算えんざん 浮動ふどう小数点しょうすうてん数すうの平方根へいほうこんを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@sin(value: anytype) @TypeOf(value)
[154] 		数値すうち演算えんざん 弧こ度ど法ほうでの正弦せいげん三さん角かく関数かんすうを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@cos(value: anytype) @TypeOf(value)
[155] 		数値すうち演算えんざん 弧こ度ど法ほうでの余弦よげん三さん角かく関数かんすうを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@tan(value: anytype) @TypeOf(value)
[156] 		数値すうち演算えんざん 弧こ度ど法ほうでの正接せいせつ三さん角かく関数かんすうを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@exp(value: anytype) @TypeOf(value)
[157] 		数値すうち演算えんざん 自然しぜん対数たいすうの底そこeの指数しすう関数かんすうを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@exp2(value: anytype) @TypeOf(value)
[158] 		数値すうち演算えんざん 底そこが2の指数しすう関数かんすうを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@log(value: anytype) @TypeOf(value)
[159] 		数値すうち演算えんざん 浮動ふどう小数点しょうすうてん数すうの自然しぜん対数たいすうを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@log2(value: anytype) @TypeOf(value)
[160] 		数値すうち演算えんざん 底そこが2の対数たいすうを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@log10(value: anytype) @TypeOf(value)
[161] 		数値すうち演算えんざん 底そこが10の対数たいすうを計算けいさんします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@abs(value: anytype) anytype
[162] 		数値すうち演算えんざん 整数せいすうまたは浮動ふどう小数点しょうすうてん数すうの絶対ぜったい値ちを返かえします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@floor(value: anytype) @TypeOf(value)
[163] 		数値すうち演算えんざん 指定していされた浮動ふどう小数点しょうすうてん数すうより大おおきくない最大さいだいの整数せいすう値ちを返かえします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@ceil(value: anytype) @TypeOf(value)
[164] 		数値すうち演算えんざん 指定していされた浮動ふどう小数点しょうすうてん数すうより小ちいさくない最小さいしょうの整数せいすう値ちを返かえします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@trunc(value: anytype) @TypeOf(value)
[165] 		数値すうち演算えんざん 指定していされた浮動ふどう小数点しょうすうてん数すうを整数せいすうに丸まるめ、ゼロに向むかって丸まるめます。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@round(value: anytype) @TypeOf(value)
[166] 		数値すうち演算えんざん 指定していされた浮動ふどう小数点しょうすうてん数すうを整数せいすうに丸まるめ、ゼロから遠とおざけます。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@subWithOverflow(a: anytype, b: anytype) struct { @TypeOf(a, b), u1 }
[167] 		数値すうち演算えんざん a - b を実行じっこうし、結果けっかと可能かのうなオーバーフロービットを持もつタプルを返かえします。 
@tagName(value: anytype) [:0]const u8
[168] 		データ変換へんかん 列挙れっきょ値ちまたはユニオン値ちを、名前なまえを表あらわす文字もじ列れつリテラルに変換へんかんします。 
@This() type
[169] 		メタプログラミング 現在げんざいの関数かんすう呼よび出だしの内部ないぶの最もっとも深ふかい構造こうぞう体たい、列挙れっきょ体たい、または共用きょうよう体たいを返かえします。 
@trap() noreturn
[170] 		デバッグ プログラムを異常いじょう終了しゅうりょうさせるためにプラットフォーム固有こゆうのトラップ/ジャム命令めいれいを挿入そうにゅうします。 
@truncate(integer: anytype) anytype
[171] 		数値すうち演算えんざん 整数せいすう型がたからビットを切きり捨すて、より小ちいさいまたは同おなじサイズの整数せいすう型がたを生成せいせいします。利用りよう可能かのうな場合ばあいは専用せんようのハードウェア命令めいれいを使用しようします。 
@Type(comptime info: std.builtin.Type) type
[172] 		メタプログラミング 型かた情報じょうほうを型かたに再さい構成こうせいします。 
@typeInfo(comptime T: type) std.builtin.Type
[173] 		メタプログラミング 型かたのリフレクション情報じょうほうを提供ていきょうします。 
@typeName(T: type) *const [N:0]u8
[174] 		メタプログラミング 型かたの文字もじ列れつ表現ひょうげんを返かえします。 
@TypeOf(...) type
[175] 		メタプログラミング 式しきの型かたを返かえします。 
@unionInit(comptime Union: type, comptime active_field_name: []const u8, init_expr) Union
[176] 		メタプログラミング ユニオンの初期しょき化か構文こうぶんと同おなじですが、フィールド名めいは識別子しきべつしトークンではなく、コンパイル時じに既知きちの値ねです。 
@Vector(len: comptime_int, Element: type) type
[177] 		データ構造こうぞう ベクトルを作成さくせいします。 
@volatileCast(value: anytype) DestType
[178] 		データ変換へんかん ポインタからvolatile修飾しゅうしょく子こを削除さくじょします。 
@workGroupId(comptime dimension: u32) u32
[179] 		プラットフォーム依存いぞん 指定していされた次元じげんのカレントカーネル呼よび出だし内ないのワークグループのインデックスを返かえします。 
@workGroupSize(comptime dimension: u32) u32
[180] 		プラットフォーム依存いぞん 指定していされた次元じげんのワークグループが持もつワークアイテムの数かずを返かえします。 
@workItemId(comptime dimension: u32) u32
[181] 		プラットフォーム依存いぞん 指定していされた次元じげんのワークグループ内ないのワークアイテムのインデックスを返かえします。この関数かんすうは0（含ふくむ）から @workGroupSize(dimension)（排他はいた的てき）までの値ねを返かえします。

ビルドモード

[編集へんしゅう]

Zigのビルドモードは、プログラムをビルドする際さいの特定とくていの設定せっていとオプションの組くみ合あわせを指定していするものです。Zigには次つぎの4つのビルドモードがあります。

  1. Debug（デフォルト）
  2. ReleaseFast
  3. ReleaseSafe
  4. ReleaseSmall

それぞれのビルドモードは、異ことなる目的もくてきに対応たいおうしています。例たとえば、デバッグ中ちゅうには実行じっこう時じのパフォーマンスよりもデバッグしやすさや安全あんぜん性せいが重要じゅうようですが、リリース時じには実行じっこう時じのパフォーマンスやバイナリサイズの最適さいてき化かが優先ゆうせんされることがあります。

ビルドモードを指定していするには、zig build-exeコマンドを使用しようします。例たとえば、ReleaseFastモードでプログラムをビルドするには、次つぎのようにします。 

$ zig build-exe example.zig -O ReleaseFast

各かくビルドモードの特性とくせいは以下いかの通とおりです。

  1. Debug:
    • 実行じっこう時じのパフォーマンスは遅おそい
    • 安全あんぜん性せいチェックが有効ゆうこう
    • ビルド速度そくどが速はやい
    • バイナリサイズが大おおきい
  2. ReleaseFast:
    • 実行じっこう時じのパフォーマンスが速はやい
    • 安全あんぜん性せいチェックが無効むこう
    • ビルド速度そくどが遅おそい
    • バイナリサイズが大おおきい
    • 再現さいげん可能かのうなビルド
  3. ReleaseSafe:
    • 実行じっこう時じのパフォーマンスは中ちゅう程度ていど
    • 安全あんぜん性せいチェックが有効ゆうこう
    • ビルド速度そくどが遅おそい
    • バイナリサイズが大おおきい
    • 再現さいげん可能かのうなビルド
  4. ReleaseSmall:
    • 実行じっこう時じのパフォーマンスは中ちゅう程度ていど
    • 安全あんぜん性せいチェックが無効むこう
    • ビルド速度そくどが遅おそい
    • バイナリサイズが小ちいさい
    • 再現さいげん可能かのうなビルド

これらのビルドモードは、プロジェクトのニーズや要件ようけんに応おうじて適切てきせつなものを選択せんたくすることが重要じゅうようです。

メモリー管理かんり

[編集へんしゅう]

Zigのメモリー管理かんりの基礎きそについて、重要じゅうようなポイントを要約ようやくします。

  1. メモリー管理かんりの責任せきにん: Zig言語げんごでは、プログラマーがメモリー管理かんりを行おこないます。つまり、Zigにはランタイムがないため、リアルタイムソフトウェア、オペレーティングシステムカーネル、組くみ込こみデバイス、低てい遅延ちえんサーバーなど、さまざまな環境かんきょうでZigコードがシームレスに動作どうさします。
  2. アロケーターの使用しよう: Zigでは、C言語げんごとは異ことなり、デフォルトのアロケーターは提供ていきょうされません。代かわりに、アロケートが必要ひつような関数かんすうは Allocator パラメーターを受うけ入いれます。データ構造こうぞうも同様どうように、初期しょき化か関数かんすうで Allocator パラメーターを受うけ入いれます。
  3. アロケーターの選択せんたく: どのアロケーターを使用しようするかは、さまざまな要因よういんに依存いぞんします。ライブラリを作成さくせいする場合ばあいやlibcをリンクする場合ばあい、またはメモリー要件ようけんが既知きちの場合ばあいなど、適切てきせつなアロケーターを選択せんたくするためのフローチャートが提供ていきょうされています。
  4. メモリーの場所ばしょ: Zigでは、異ことなる種類しゅるいのデータが異ことなる場所ばしょに配置はいちされます。例たとえば、関数かんすう内ないのvar宣言せんげんはその関数かんすうのスタックフレームに配置はいちされます。一方いっぽう、グローバルレベルや構造こうぞう体内たいないのvar宣言せんげんはグローバルデータセクションに配置はいちされます。
  5. アロケーターの実装じっそう: Zigプログラマーは、Allocator インターフェースを満みたすことで独自どくじのアロケーターを実装じっそうできます。これには、allocFnとresizeFnを提供ていきょうする必要ひつようがあります。
  6. 再帰さいき: 再帰さいきは、Zigでモデリングソフトウェアにおいて基本きほん的てきなツールですが、無む制限せいげんのメモリー割わり当あて問題もんだいがあります。現在げんざい、再帰さいきは通常つうじょうどおり動作どうさしますが、将来しょうらいのZigバージョンではスタックオーバーフローからの保護ほごが提供ていきょうされる予定よていです。
  7. ライフタイムと所有しょゆう権けん: ポインターが指さすメモリが使用しようできなくなった場合ばあいに、そのポインターにアクセスしないようにすることが、Zigプログラマーの責任せきにんです。所有しょゆう権けんとライフタイムのセマンティクスは、ポインターの所有しょゆう者しゃとメモリーの使用しよう可能かのうな期間きかんを明確めいかくにするために、関数かんすうやデータ構造こうぞうのAPIドキュメントで説明せつめいされるべきです。

Zigは、メモリー管理かんりに関かんする柔軟じゅうなん性せいと制御せいぎょを提供ていきょうし、プログラマーがそのアプリケーションのニーズに合あわせて最適さいてきなアロケーターを選択せんたくできるようにしています。

メモリー管理かんりの責任せきにんとアロケーター

[編集へんしゅう]

Zig言語げんごはプログラマーに代かわってメモリー管理かんりを行おこなうことはありません。このため、Zigにはランタイムがなく、Zigのコードはリアルタイム・ソフトウェア、OSカーネル、組込くみこみ機器きき、低てい遅延ちえんサーバーなど、多おおくの環境かんきょうでシームレスに動作どうさします。その結果けっか、Zigのプログラマーは常つねに次つぎのような問といに答こたえられなければなりません[182]。

『バイトはどこにあるのか？』

Zigと同様どうよう、C言語げんごもメモリー管理かんりを手動しゅどうで行おこなっています。しかし、Zigとは異ことなり、C言語げんごにはmalloc、realloc、freeというデフォルトのアロケーターがあります。libc とリンクするとき、Zig はこのアロケーターを std.heap.c_allocator で公開こうかいします。しかし、慣習かんしゅうとして、Zig にはデフォルトのアロケーターはありません。代かわりに、割当わりあてが必要ひつような関数かんすうは Allocator パラメーターを受うけ取とります。同様どうように、std.ArrayList のようなデータ構造こうぞうもその初期しょき化か関数かんすうで Allocator パラメーターを受うけ付つけます。

allocator.zig
const std = @import("std");
const Allocator = std.mem.Allocator;
const stdout = std.io.getStdOut().writer();

pub fn main() !void {
    var buffer: [100]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buffer);
    const allocator = fba.allocator();
    const result = try concat(allocator, "foo", "bar");
    try stdout.print("concat(allocator, \"foo\", \"bar\") ⇒ \"{s}\"\n", .{result});
}

fn concat(allocator: Allocator, a: []const u8, b: []const u8) ![]u8 {
    const result = try allocator.alloc(u8, a.len + b.len);
    std.mem.copy(u8, result, a);
    std.mem.copy(u8, result[a.len..], b);
    return result;
}
実行じっこう結果けっか
concat(allocator, "foo", "bar") ⇒ "foobar"

上記じょうきの例れいでは、スタック上じょうの 100 バイトのメモリーが FixedBufferAllocator の初期しょき化かに使つかわれ、それが関数かんすうに渡わたされます。

利便りべん性せいのために std.testing.allocator でグローバルな FixedBufferAllocator が用意よういされており、基本きほん的てきなリーク検出けんしゅつも行おこなうことができます。

Zig には std.heap.GeneralPurposeAllocator でインポート可能かのうな汎用はんようアロケーターがあります。しかし、やはり、アロケーターの選えらび方かたの指針ししんに従したがうことが推奨すいしょうされます。

アロケーターの選えらび方かた

[編集へんしゅう]

どのアロケーターを使つかうかは、様々さまざまな要因よういんによって決きまります。以下いかは、判断はんだんのためのフローチャートです[183]。

  1. ライブラリーを作つくっているのですか？この場合ばあい、パラメーターとしてアロケーターを受うけ取とり、ライブラリーのユーザーにどのアロケーターを使つかうかを委ゆだねるのがベストです。
  2. libc をリンクしていますか? この場合ばあい、少すくなくともメインのアロケーターは std.heap.c_allocator が正ただしい選択せんたくだと思おもわれます。
  3. 必要ひつようなバイト数すうの最大さいだい値ちは、コンパイル時じに分わかっている数かずで制限せいげんされていますか? この場合ばあい、スレッドセーフが必要ひつようかどうかによって std.heap.FixedBufferAllocator か std.heap.ThreadSafeFixedBufferAllocator を使つかってください。
  4. あなたのプログラムはコマンドラインアプリケーションで、基本きほん的てきな循環じゅんかんパターンを持もたずに最初さいしょから最後さいごまで実行じっこうされ（ビデオゲームのメインループやウェブサーバーのリクエストハンドラーなど）、最後さいごにすべてを一いち度どに解放かいほうすることに意味いみがあるようなものでしょうか？このような場合ばあい、このパターンに従したがうことをお勧すすめします。
    cli_allocation.zig
    const std = @import("std");

pub fn main() !void {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();

    const allocator = arena.allocator();

    const ptr = try allocator.create(i32);
    std.debug.print("ptr={*}\n", .{ptr});
}
    実行じっこう結果けっか
    ptr=i32@7fcdf92dd018
    この種たねのアロケーターを使用しようする場合ばあい、手動しゅどうで何なにかを解放かいほうする必要ひつようはありません。arena.deinit()を呼よび出だすと、すべてが一いち度どに解放かいほうされます。
  5. ビデオゲームのメインループやウェブサーバのリクエストハンドラのような周期しゅうき的てきなパターンの一部いちぶでしょうか？例たとえば、ビデオゲームのフレームが完全かんぜんにレンダリングされた後のちや、ウェブサーバーのリクエストが処理しょりされた後のちなど、サイクルの終おわりにすべてのアロケーションを一いち度どに解放かいほうできる場合ばあい、std.heap.ArenaAllocator は素晴すばらしい候補こうほとなります。前まえの箇条書かじょうがきで示しめしたように、これによってアリーナ全体ぜんたいを一いち度どに解放かいほうすることができます。また、メモリの上限じょうげんを設定せっていできる場合ばあいは、std.heap.FixedBufferAllocator を使用しようすると、さらに最適さいてき化かできることに注意ちゅういしましょう。
  6. テストを書かいていて、error.OutOfMemoryが正ただしく処理しょりされることを確認かくにんしたいですか？この場合ばあいは std.testing.FailingAllocator を使つかってください。
  7. テストを書かいていますか？この場合ばあいは std.testing.allocator を使つかってください。
  8. 最後さいごに、上記じょうきのどれにも当あてはまらない場合ばあいは、汎用はんようのアロケーターが必要ひつようです。Zigの汎用はんようアロケーターは、設定せっていオプションのcomptime構造こうぞう体たいを受うけ取とり、型かたを返かえす関数かんすうとして提供ていきょうされている。一般いっぱん的てきには、メイン関数かんすうに std.heap.GeneralPurposeAllocator をひとつセットアップし、アプリケーションの様々さまざまな部分ぶぶんにそのアロケーターやサブアロケーターを渡わたしていくことになる。
  9. アロケーターの実装じっそうを検討けんとうすることもできます。

バイトはどこにあるのか？

[編集へんしゅう]

Where are the bytes?

”foo” のような文字もじ列れつリテラルは、グローバル定数ていすうデータセクション( global constant data section )にあります。このため、文字もじ列れつリテラルをミュータブルスライスに渡わたすとエラーになります[184]。

文字もじ列れつリテラルと同様どうように、コンパイル時じに値ねが分わかっているconst宣言せんげんは、グローバル定数ていすうデータセクションに格納かくのうされます。また、コンパイル時じ変数へんすうもグローバル定数ていすうデータセクションに格納かくのうされます。

関数かんすう内ないのvar宣言せんげんは、その関数かんすうのスタックフレームに格納かくのうされます。関数かんすうから戻もどると、関数かんすうのスタックフレームにある変数へんすうへのポインターは無効むこうな参照さんしょうとなり、その参照さんしょう解除かいじょは未み確認かくにんの未み定義ていぎ動作どうさとなります。

アロケーターの実装じっそう

[編集へんしゅう]

Zig プログラマーは Allocator インターフェースを満みたすことで、自分じぶん自身じしんのアロケーターを実装じっそうすることができます。そのためには、std/mem.zig のドキュメントコメントをよく読よんで、allocFn と resizeFn を指定していする必要ひつようがあります[185]。

インスピレーションを得えるために、多おおくのアロケータの例れいを見みることができます。std/heap.zig と std.heap.GeneralPurposeAllocator を見みてください。

ヒープアロケーションの失敗しっぱい

[編集へんしゅう]

多おおくのプログラミング言語げんごでは、ヒープ割わり当あてに失敗しっぱいした場合ばあい、無条件むじょうけんにクラッシュすることで対処たいしょすることにしています[186]。

Zig のプログラマは、慣習かんしゅうとして、これが満足まんぞくのいく解決かいけつ策さくであるとは考かんがえていません。

その代かわり、error.OutOfMemoryはヒープ割わり当あての失敗しっぱいを表あらわし、Zigライブラリーはヒープ割わり当あての失敗しっぱいで処理しょりが正常せいじょうに完了かんりょうしなかったときはいつでもこのエラーコードを返かえします。

Linuxなどの一部いちぶのOSでは、デフォルトでメモリーのオーバーコミットが有効ゆうこうになっているため、ヒープ割わり当あての失敗しっぱいを処理しょりすることは無意味むいみであると主張しゅちょうする人ひともいます。この理由りゆうには多おおくの問題もんだいがあります。

  1. オーバーコミット機能きのうを持もつのは一部いちぶのOSだけである。
    • Linuxはデフォルトで有効ゆうこうになっていますが、設定せってい可能かのうです。
    • Windowsはオーバーコミットしません。
    • 組込くみこみシステムはオーバーコミットしません。
    • ホビー用ようOSはオーバーコミットがあってもなくてもよい。
  2. リアルタイムシステムでは、オーバーコミットがないだけでなく、通常つうじょう、アプリケーションごとの最大さいだいメモリ容量ようりょうがあらかじめ決きめられています。
  3. ライブラリーを作成さくせいする場合ばあい、コードの再さい利用りようが主おもな目的もくてきの1つです。ライブラリーの作成さくせいにおいて、コードの再さい利用りようは重要じゅうような目的もくてきの一ひとつである。
  4. オーバーコミットが有効ゆうこうであることに依存いぞんしているソフトウェアもありますが、その存在そんざいは数かぞえ切きれないほどのユーザー体験たいけんの破壊はかいの原因げんいんとなっています。オーバーコミットを有効ゆうこうにしたシステム、例たとえばLinuxのデフォルト設定せっていでは、メモリーが枯渇こかつしそうになると、システムがロックして使つかえなくなる。このとき、OOM Killer はヒューリスティックに基もとづき kill するアプリケーションを選択せんたくします。この非決定ひけってい的てきな判断はんだんにより、重要じゅうようなプロセスが強制きょうせい終了しゅうりょうされることが多おおく、システムを正常せいじょうに戻もどすことができないことがよくあります。

再帰さいき

[編集へんしゅう]

再帰さいき( Recursion )はソフトウェアをモデリングする際さいの基本きほん的てきなツールである。しかし、再帰さいきにはしばしば見落みおとされがちな問題もんだいがあります[187]。

再帰さいきはZigで活発かっぱつに実験じっけんされている分野ぶんやであり、ここにある文書ぶんしょは最終さいしゅう的てきなものではありません。0.3.0のリリースノートで、再帰さいきの状況じょうきょうを要約ようやくして読よむことができます。

簡単かんたんにまとめると、現在げんざいのところ再帰さいきは期待きたい通どおりに動作どうさしています。Zigのコードはまだスタックオーバーフローから保護ほごされていませんが、Zigの将来しょうらいのバージョンでは、Zigのコードからのある程度ていどの協力きょうりょくが必要ひつようですが、そのような保護ほごを提供ていきょうすることが予定よていされています。

ライフタイムとオーナーシップ

[編集へんしゅう]

ポインターを指さしているメモリーが利用りようできなくなったときに、ポインターにアクセスしないようにするのは、Zigのプログラマーの責任せきにんです。スライスは、他たのメモリーを参照さんしょうするという点てんで、ポインターの一種いっしゅであることに注意ちゅういしてください [188]。

バグを防ふせぐために、ポインターを扱あつかうときに従したがうと便利べんりな規則きそくがあります。一般いっぱんに、関数かんすうがポインターを返かえす場合ばあい、その関数かんすうのドキュメントでは、誰だれがそのポインターを「所有しょゆう」しているかを説明せつめいする必要ひつようがあります。この概念がいねんは、プログラマーがポインターを解放かいほうすることが適切てきせつである場合ばあい、そのタイミングを判断はんだんするのに役立やくだちます。

例たとえば、関数かんすうのドキュメントに「返かえされたメモリーは呼よび出だし元もとが所有しょゆうする」と書かかれていた場合ばあい、その関数かんすうを呼よび出だすコードは、いつそのメモリーを解放かいほうするかという計画けいかくを持もっていなければなりません。このような場合ばあい、おそらく関数かんすうは Allocator パラメーターを受うけ取とります。

時ときには、ポインターの寿命じゅみょうはもっと複雑ふくざつな場合ばあいがあります。例たとえば、std.ArrayList(T).items スライスは、新あたらしい要素ようそを追加ついかするなどしてリストのサイズが次つぎに変更へんこうされるまで有効ゆうこうです。

関数かんすうやデータ構造こうぞうのAPIドキュメントでは、ポインターの所有しょゆう権けんと有効ゆうこう期限きげんについて細心さいしんの注意ちゅういを払はらって説明せつめいする必要ひつようがあります。所有しょゆう権けんとは、ポインターが参照さんしょうするメモリーを解放かいほうする責任せきにんが誰だれにあるかということであり、寿命じゅみょうとは、メモリーがアクセス不能ふのうになる時点じてん（未定義みていぎ動作どうさが発生はっせいしないように）を決きめることです。

C言語げんごとの相互そうご運用うんよう

[編集へんしゅう]

ZigはC言語げんごから独立どくりつしており、他たの多おおくの言語げんごとは異ことなりlibcに依存いぞんしませんが、Zigは既存きそんのC言語げんごで書かかれたとの相互そうご作用さようの重要じゅうよう性せいを認みとめています[189]。

ZigはC言語げんごとの相互そうご運用うんようを容易よういにするために、いくつかの方法ほうほうを用意よういしています。

C言語げんご型がたプリミティブ

[編集へんしゅう]

以下いかに示しめすZigの型かたはC言語げんごとのABI互換ごかん性せいが保証ほしょうされており、他たの型かたと同様どうように使用しようすることができます[190]。

C の void 型がたと相互そうご運用うんようする場合ばあいは anyopaque を使用しようします。

「プリミティブ型がた」も参照さんしょう

C言語げんごヘッダーからのインポート

[編集へんしゅう]

組込くみこみ関数かんすう @cImport を使用しようすると、.h ファイルからシンボルを直接ちょくせつインポートすることができます[191]。 @cImport 関数かんすうは、パラメーターとして式しきを受取うけとります。この式しきはコンパイル時じに評価ひょうかされ、プリプロセッサー指令しれいの制御せいぎょや複数ふくすうの.hファイルをインクルードするために使用しようされます。

「@cImport」、「@cInclude」、「@cDefine」、「@cUndef」、および「@import」も参照さんしょう

C言語げんご翻訳ほんやく CLI

[編集へんしゅう]
コマンドライン・フラグ
[編集へんしゅう]
target と -cflags の使用しよう
[編集へんしゅう]
cImportとtranslate-cの比較ひかく
[編集へんしゅう]

C言語げんご翻訳ほんやくキャッシュ

[編集へんしゅう]

翻訳ほんやくの失敗しっぱい

[編集へんしゅう]

C言語げんごマクロ

[編集へんしゅう]

C言語げんごポインター

[編集へんしゅう]

C言語げんごライブラリーのエクスポート

[編集へんしゅう]

オブジェクトファイルの混在こんざい

[編集へんしゅう]

キーワード一覧いちらん

[編集へんしゅう]
align
ポインターのアライメントを指定していするために使用しようします。
また、変数へんすうや関数かんすうの宣言せんげんの後のちに使用しようして、その変数へんすうや関数かんすうへのポインターのアライメントを指定していすることができます。
allowzero
ポインターの属性ぞくせい allowzero は、ポインターのアドレスが 0 であることを許可きょかします。
and
論理ろんり積せき
anyframe
関数かんすうフレームへのポインターを保持ほじする変数へんすうの型かたとして使用しようすることができます。
anytype
関数かんすうのパラメーターは、型かたの代かわりにanytypeで宣言せんげんすることができます。型かたは関数かんすうが呼出よびだされた場所ばしょで推測すいそくされます
asm
インラインアセンブリ式しきを開始かいしします。これにより、コンパイル時じに生成せいせいされる機械きかい語ごを直接ちょくせつ制御せいぎょすることが