Zig 컴파일러, 핵심 문법, 테스트, 디버깅 및 저수준 프로그래밍 기능을 살펴보는 입문서입니다.
Nilo Stolte
45년에 걸친 제 경력에서 Zig보다 더 큰 놀라움을 준 언어는 떠오르지 않습니다. 제 생각에 Zig는 단지 새로운 프로그래밍 언어가 아니라, 프로그램을 작성하는 완전히 새로운 방식입니다. 단지 C나 C++를 대체하는 언어라고 말하는 것은 엄청난 과소평가입니다.
이 글에서는 제가 이 언어에서 가장 매력적으로 느낀 기능들을 소개하고, 간략한 개요도 제시하겠습니다. 목표는 프로그래머가 언어를 빠르게 시작할 수 있도록 단순한 기능들을 제시하는 것입니다. 다만 산업계에서의 수용성에는 훨씬 더 많은 기능이 영향을 미친다는 점을 유념해야 합니다.
Zig 컴파일러의 가장 놀라운 장점은 C 코드를 컴파일할 수 있는 능력일 것입니다. 이것이 원래 컴파일된 머신과 다른 아키텍처에서 실행될 코드를 크로스 컴파일하는 능력과 결합되면, 이미 상당히 다르고 독특한 무언가가 됩니다. 이 기능들만으로도, 완전히 즉시 사용 가능한 상태로, 이미 업계에 놀라운 영향을 미치고 있습니다.그럼에도 우리가 집중하려는 것은 Zig로 프로그래밍하는 방법과 다른 어떤 언어가 아니라 Zig를 선택해야 하는 이유입니다.
컴파일러 설치는 아주 간단합니다.Zinglang의 다운로드 페이지에서 프로세서나 OS에 따라 여러 형식의 컴파일러를 찾을 수 있습니다.
Windows 10에서는 예를 들어 x86_64 zip 파일을 선택하고 압축을 푼 내용을 원하는 디렉터리에 복사합니다. 예를 들어 “Program Files”에 둘 수 있습니다. 다른 버전의 컴파일러를 복사할 때 Path 환경 변수의 경로를 수정할 필요가 없도록 루트 디렉터리 이름을 “zig-windows-x86_64”로 바꾸었습니다.
다음으로 고급 시스템 속성을 사용해 이 루트 디렉터리 경로를 Path 환경 변수에 추가합니다(1~4를 클릭하고, 5에 경로를 붙여 넣은 뒤, 6~8에서 “OK”를 클릭합니다).
Zig의 루트 디렉터리 경로를 설정한 뒤에는 이미 CLI 모드에서 컴파일러를 사용할 수 있다는 점에 유의하십시오. 단순성을 위해 이것이 권장되는 사용 방법입니다.
이 사이트의 “Getting Started” 섹션에 있는 지침에 따라 “Hello World!” 프로그램을 빌드하는 것이 권장됩니다. MacOS와 Linux를 포함한 대체 설치 절차도 그곳에 제시되어 있습니다(“Installing manually”를 강력히 권장합니다). Zig 언어를 더 깊이 이해하려면 “Language” 기초 섹션도 확인하는 것이 좋습니다.
다음 섹션들은 Zig 언어를 개괄적으로 살펴봅니다. 목표는 프로그래머가 몇 가지 기본 개념과 명령만으로 Zig 프로그래밍을 빠르게 시작하도록 안내하는 것입니다.
이어서 프로그램을 빌드하고 모듈을 테스트하는 방법을 간략히 살펴봅니다.
마지막으로 Zig에서 저수준 프로그래밍을 수행하는 방법을 더 깊이 살펴봅니다. 사용된 예제에 대한 상세한 설명도 제공합니다.
일반적으로 Zig의 변수 선언은 세 부분으로 이루어질 수 있습니다. 첫 번째 부분에는 접근성(pub 또는 없음), 이어서 var 또는 const라는 단어, 그리고 변수 이름이 들어갑니다. 첫 번째 부분과 콜론으로 구분되는 두 번째 부분에는 변수 타입 선언이 들어갑니다. 세 번째 부분은 변수의 초기화입니다. Zig에서는 첫 번째와 세 번째 부분만 필수이며, Java나 C에서 왔다면 다소 당황스러울 수 있습니다. 컴파일러가 변수 타입을 어떻게 알아내는지 의문이 들 수 있습니다. 이 경우 타입은 초기화에 의해 추론됩니다.
var sum : usize = 0; // 3부분으로 된 변수 선언
변수의 접근성이 명시적으로 pub으로 선언되지 않으면 해당 변수는 모듈에 지역적입니다. 즉, 선언된 소스 파일 밖에서는 접근할 수 없습니다(C의 static 변수와 같습니다). 변수를 pub으로 선언하는 것은 권장되지 않으며, 결합도를 낮추고 응집도를 높이기 위해 모듈에서 pub으로 선언하는 함수도 적게 두는 것이 좋습니다. pub 함수는 모듈의 API처럼 동작합니다.
Zig에서 .{로 시작하여 }로 닫히는 것은 _“익명 구조체 리터럴”_입니다. 이는 주로 다른 구조체의 요소를 초기화하거나 요소가 초기화된 새 구조체를 만들 때 사용하는 익명 구조체입니다. .{ }는 비어 있는 익명 구조체 리터럴입니다. struct 뒤에 {가 오고 }로 닫히는 것은 구조체 선언입니다. 타입을 사용해 변수를 초기화할 수 있으며, 이는 해당 타입의 별칭 역할을 합니다. 실행 파일 없이 테스트를 컴파일하고 실행할 수 있게 하는 _“테스트 블록”_에 주목하십시오.
비트 필드는 packed struct 안에서 특정 크기를 가진 타입으로 선언된 필드입니다. 포인터는 여기서 보이는 것처럼 특정 비트 필드를 가리킬 수 있습니다.
Zig의 문법은 C보다 명확합니다. 다만 [0..8]이어야 한다고 생각할 수 있지만, 실제로는 열린 구간인 [0..9)입니다. Zig의 장점: i의 타입 선언, 초기화, 테스트 및 증분이 자동으로 이루어집니다.
[_]는 크기를 알 수 없는 배열을 정의합니다. 뒤에는 요소의 타입(여기서는 _부호 없는 바이트_인 u8)과 { 및 } 사이의 초기화가 와야 합니다. 아래 예제에서 초기화는 각 요소가 u8 타입(부호 없는 바이트)이고 각 요소가 0으로 초기화된({0} ** 81) 크기 미지의 배열([_])이라는 뜻입니다. 초기화({0})의 반복 계수(81)로부터 크기도 추론된다는 점에 유의하십시오.
var grid = [_]u8{0} ** 81;
아래 그림에서는 루프가 배열을 순회하며 그 요소들을 더하는 테스트 환경을 볼 수 있습니다. try expect 문은 sum이 올바른지 검증합니다.
byte라는 단어는 Zig에서 타입이나 예약어가 아닙니다. 여기서는 루프의 각 단계에서 배열의 각 요소를 담는 변수입니다. for 루프의 괄호 안에 배열과 함께 두 | 사이에 선언된 변수는 항상 배열 요소와 같은 타입으로 간주된다는 점에 유의하십시오.
또한 usize는 플랫폼의 자연스러운 부호 없는 정수입니다. 즉, 64비트 머신에서는 u64이고 32비트 머신에서는 u32입니다.
배열 포인터는 포인터가 여기의 [*]const i32처럼 명시적으로 다중 항목 포인터로 선언된 경우에만 포인터 산술을 사용할 수 있습니다. 아래 배열은 변경할 수 없는 const이지만 포인터는 var라는 점에 유의하십시오.
개별 배열 위치의 주소가 할당된 포인터는 포인터 산술로 갱신할 수 없습니다. 이 경우 const는 다른 직접 주소 할당으로 값을 변경하는 것만 막습니다. Zig에서 포인터를 역참조하려면 아래와 같이 ptr.*를 사용합니다.
Zig는 컴파일 시간에 많은 일을 할 수 있습니다. 예를 들어 배열을 초기화해 봅시다. 여기서는 _레이블이 있는 break_를 사용합니다. 블록은 이름 init 뒤의 :로 레이블을 붙이고, 이어서 break로 블록에서 값을 반환합니다.
이 문법은 압도적으로 보일 수 있습니다.
0..는 0에서 시작하는 무한 범위를 의미합니다. for에서 변수 pt와 i는 각각 initial_value 배열의 주소와 0으로 초기화됩니다. 루프 동안 둘 다 자동으로 증가하며, 배열의 마지막 위치를 처리한 직후 루프가 멈춥니다. 또한 pt 포인터를 역참조하는 방법인 pt.*에 주목하십시오.
레이블이 있는 블록에서 배열을 선언하는 방법도 흥미롭습니다. 배열 이름은 initial_value이고 Point 타입(뒤에서 선언됨)의 위치 10개를 가집니다. Zig에서는 변수를 초기화해야 합니다. 명시적으로 초기화하지 않는 방법은 예약어 undefined를 사용하는 것입니다.
Zig의 함수는 fn으로 선언되며, fn 앞에 pub이 오지 않는 한 선언된 파일에서 기본적으로 정적입니다(다른 파일에서 가져올 수 없음). 함수는 “인라인”될 수 있습니다. 함수 포인터 앞에는 const가 오고 뒤에는 함수 프로토타입이 옵니다.
구조체는 함수를 가질 수 있습니다. 여기서는 간단한 스택을 구현합니다. 이 스택은 정의된 모듈 내부에서만 선언되고 사용되며, 이 예제에서는 중요하지 않은 모듈 내 다른 자료구조에 접근하고 수정합니다. 스택은 최대 81개의 요소를 가질 수 있으며(stk 선언에서 확인할 수 있음), 각 요소는 StkNode 타입입니다. Zig에는 ++ 및 –– 연산자가 없다는 점에 유의하십시오. 대신 += 및 –=에 해당하는 연산자를 사용해야 합니다. 스택 포인터는 stk 배열의 인덱스로 쓰이는 정수일 뿐입니다.
일반적으로 예상하는 것처럼 포인터 self(self는 예약어가 아니라 관례일 뿐임)가 매개변수로 명시적으로 전달되지 않는다는 점에 유의하십시오. 이 포인터는 함수가 호출된 스택 인스턴스의 포인터라고 간접적으로 가정됩니다. 아래 예제에서 스택 pop은 stack.pop();으로 호출됩니다. 이 경우 포인터 self는 stack에 대한 포인터에 해당합니다. 따라서 이 포인터는 Java나 C++의 this와 어느 정도 동등합니다.
함수 init()는 스택 생성자입니다.
함수 pop과 push가 “인라인”된다는 점도 유의하십시오.
실행 프로그램을 빌드하려면 Java나 C 프로그램처럼 프로그램 진입점을 나타내는 main 함수가 필요합니다. 이 함수가 있으면 모듈 집합을 실행 코드로 컴파일할 수 있습니다. 간단한 프로그램은 나머지 프로그램과 같은 파일에 main 함수를 둘 수 있습니다. 많은 경우 모듈을 독립적으로 디버그하기 위해 모듈 끝에 main 함수를 삽입하여 실행 파일을 만들 수도 있습니다. 디버깅이 끝나면 이 함수는 주석 처리할 수 있습니다.
이러한 상황에서는 다음 명령줄을 사용하여 program.zig를 컴파일하고 실행 프로그램을 생성할 수 있습니다(Windows에서는 program.exe).
zig build-exe -O ReleaseFast program.zig
오타를 방지하기 위해 이를 배치 파일에 넣을 수 있습니다.
이것은 프로그래밍 언어로서 Zig의 최고의 기능일 것입니다. 이 환경은 보통 테스트에 쓰이지만 프로토타이핑에도 사용할 수 있습니다.
Zig의 블록은 C나 Java의 블록과 비슷합니다. 즉, {와 } 사이에 있는 코드입니다. _테스트 블록_은 test "message" {로 시작하고 }로 끝나는 블록이며, 여기서 "message"는 테스트 실행 시 표시할 메시지를 포함하는 문자열입니다(이 경우에는 _message_라는 단어뿐입니다).
테스트 블록은 실행 파일과 독립적으로 실행됩니다. 최종 실행 파일은 테스트를 실행하지 않습니다. 지정된 module.zig의 테스트 블록은 해당 파일의 전체 코드와 함께 컴파일되며 다음 명령으로 실행됩니다.
zig test module.zig
실제 사례로 모듈 example.zig의 _테스트 블록_을 아래에 보입니다.
test " => testing set and print functions" {
set(
"800000000003600000070090200" ++
"050007000000045700000100030" ++
"001000068008500010090000400"
);
std.debug.print("\n" ++
"===================\n" ++
"Input Grid\n" ++
"===================\n",
.{}
);
print();
}
example.zig만으로는 main 함수가 없으므로 실행 파일을 생성할 수 없지만, 다음 명령을 사용하면 테스트 블록을 실행할 수 있습니다.
zig test example.zig
메시지가 말하듯 위 테스트 블록은 set 및 print 함수를 테스트합니다. 코드에서 볼 수 있듯이 set은 십진수 숫자 문자열을 매개변수로 전달받고, 이어서 “Input Grid”라는 헤더를 출력하는 print 문이 오며, 그 뒤에 print 함수 호출이 옵니다.
명령 도구에서의 실제 표시는 다음과 같습니다.
이제 std.debug.print 문에 집중해 봅시다. 이 문은 사실 표준 Zig 라이브러리 std의 debug.zig에 있는 print 함수 호출입니다. 첫 번째 매개변수는 형식 문자열이고, 두 번째는 형식 문자열로 표시할 변수 목록을 담은 점으로 시작하는 _익명 구조체_입니다. 형식 문자열에 서식이 없으므로 구조체는 비어 있습니다. 이것이 서식 있는 출력을 하는 방법입니다. 위에서 보인 것처럼 기본적으로 _stderr_에 표시됩니다.
이 모든 것은 C 언어와 똑같아 보이지만, 근본적인 차이가 있습니다. C에서는 printf 함수가 실행 시간에 형식 문자열을 동적으로 해석하는 반면, Zig에서는 컴파일 시간에 리터럴 문자열과 변수 목록을 다룰 수 있습니다. 처음에는 이해하기 어려운 원리입니다. 많은 것이 컴파일 시간에 _실행_될 수 있습니다.
디버거를 사용하는 일은 이미 디버거가 통합된 IDE(Java IDE인 Eclipse 또는 Intellij IDEA 등)나 통합 개발 키트(C/C++용 w64devkit 등)가 아니라면 보통 간단하지 않습니다.
이런 방식으로 디버거를 사용할 때 큰 불편은 심볼을 통합해야 한다는 점입니다. 이는 프로그램에 쓸모없는 정보로 코드를 부풀릴 뿐 아니라, 효율이 현저히 떨어지는 실행 코드를 생성하는 Debug 모드로 컴파일해야 합니다. 복잡한 시스템에 익숙한 사람은 이것이 아주 많은 시간을 소모하는 작업일 수 있음을 압니다.
Zig는 이런 골칫거리를 피하기 위한 매우 편리한 방법을 제공합니다.
이 내장 기능은 실행 파일을 디버거에서 실행할 때 소스 코드에 @breakpoint();를 삽입한 지점에서 프로그램을 멈춥니다. 이는 심볼 없이 최적화된 Zig 코드를 디버그하는 유용한 기능입니다.
필요한 것은 @breakpoint(); 바로 전에 std.debug.print를 사용해 보고 싶은 변수를 추적하는 것뿐입니다. 이렇게 하면 정확히 그 순간 변수 값이 무엇인지 알 수 있습니다.
실제 사례로 다음 main 함수를 가진 모듈 debug_example.zig의 실행 파일을 생성합니다.
pub fn main() !void {
set(
"800000000003600000070090200" ++
"050007000000045700000100030" ++
"001000068008500010090000400"
);
}
example.zig의 결과와 다시 확인할 수 있도록, 이 main에서 set 함수에 전달되는 매개변수는 example.zig의 테스트 블록에서 set에 전달된 문자열과 같습니다. 하지만 이번에는 set 함수 내부에 다음 코드를 삽입합니다.
if (c != 0) {
print();
std.debug.print(
"Current digit {}\nposition in string {}\n" ++
"line {}\ncolumn {}\ncode {b}\n",
.{c, k, i, j, code}
);
@breakpoint();
}
이제 다음 빌드 명령으로 debug_example.exe 실행 파일을 생성할 수 있습니다.
zig build-exe debug_example.zig
다음으로 디버거를 사용해 debug_example.exe를 호출합니다. 이 경우 w64devkit에 포함된 C/C++ 디버거인 gdb를 사용했지만, 실행 프로그램용 디버거라면 무엇이든 될 수 있습니다. gdb에 들어가면 아래에 보이는 것처럼 r 명령과 바로 뒤의 Enter를 입력하여 프로그램을 실행해야 합니다. 프로그램이 지금까지의 내용을 담은 그리드와 변수들을 출력하고 예상한 지점에서 멈췄다는 점에 유의하십시오. 이후 c 명령과 Enter를 입력하면 그리드 내용과 변수 추적을 계속합니다. 그다음에는 Enter만 입력해도 계속할 수 있습니다(이 경우 마지막 명령인 c를 반복합니다). 프로그램이 끝날 때까지 Enter를 계속 입력하면, 두 예제 모두 set에 같은 매개변수를 전달하므로 그리드에서 발견되는 값은 위 example.zig의 테스트 블록이 보여 준 값과 일치합니다.
이전 섹션에서 소개와 예제를 통해 일반 애플리케이션을 작성하는 Zig 프로그래밍은 이미 시작할 수 있습니다. 고급 프로그래머를 위해, 다음에서는 예제에서 이미 사용되었지만 아직 명시적으로 언급되지 않은 흥미로운 저수준 기능을 더 깊이 분석합니다.
제시된 예제의 목적은 9x9 행렬을 설정(초기화)하고 표시하는 모듈을 구성하는 것입니다. 이 행렬은 Sudoku 그리드를 담으며, 즉 십진수 숫자를 가진 요소만 포함합니다. 그리드 초기화는 그리드가 Sudoku 게임 규칙을 만족하도록 보장해야 하므로 오류를 포함하지 않습니다.
동시에 이는 적어도 가장 눈에 띄는 Zig의 저수준 기능을 보여 줄 좋은 기회이며, 이 예제들은 이 목표에 아주 잘 맞습니다.
이 예제들 뒤의 전체 가정은 값이 지정하는 위치의 비트로 그리드 숫자를 표현하는 것입니다. 이 표현은 숫자가 그리드에 이미 존재하는지 감지하는 데 아주 편리합니다(Sudoku 그리드의 기본 규칙입니다). 그럼에도 이는 매우 암호화되어 있어 모듈 내부에서만 사용됩니다.
사람이 쉽게 이해할 수 있는 값을 갖기 위해 숫자는 실제로 표준 u8 정수로 행렬에 저장됩니다. 예제의 입력 그리드는 문자열 형식으로 주어지지만, ASCII 문자는 내부적으로 u8 정수로 변환됩니다. 그리드의 숫자 저장은 예제에서 grid라고 부르는 위치 81개의 배열에 행 단위로 선형 구성됩니다.
var grid = [_]u8{0} ** 81; // Sudoku grid stored linearly
그리드의 정확성을 검증하려면 각 행과 열로 요소에 접근해야 합니다. 다시 말해 행렬에서처럼 요소에 접근해야 합니다. 전략은 위치 9개를 가진 포인터 배열을 만들고, 각 포인터가 각 행의 시작을 가리키게 하는 것입니다. 코드 블록은 원칙적으로 값을 반환할 수 없지만, Zig에서는 레이블이 있는 break로 가능합니다.
const matrix = fill9x9: { // matrix array to allow access
var m : [9][*]u8 = undefined; // to grid element as a matrix,
var pt : [*]u8 = &grid; // thus: element = matrix[i][j]
for (0..9) |i| { //
m[i] = pt; // stores pointers of each line
pt += 9; // at each position of matrix
} //
break :fill9x9 m; // initializes matrix with m
};
루프 끝에서 m은 break :fill9x9 m; 명령으로 블록 밖에 반환됩니다. fill9x9는 블록 시작 바로 앞에 둔 레이블의 이름에 해당한다는 점에 유의하십시오.
각각 요소의 행과 열인 i와 j가 있다고 가정하면, 그리드의 모든 요소에는 다음 표기법으로 접근할 수 있습니다.
element = matrix[i][j]
여기서 사용되는 핵심 개념은 정수 십진수 숫자 i를 다음과 같은 정수 code로 대체하는 것입니다.
i ∈ [1,9] → code = 2ⁱ⁻¹
i = 0 → code = 0
다시 말해, i가 1과 9 사이이면 1로 설정된 code의 유일한 비트는 위치 i-1의 비트이고, 그렇지 않으면 code의 모든 비트는 0입니다.
code 값아래 표는 숫자와 이진 표현 간의 대응을 보여 줍니다.
code 계산하기code 값은 c가 0이 아닌 경우에만 왼쪽 시프트 연산자를 사용하여 set 함수에서 계산됩니다.
code = @as(u9,1) << (c-1);
Zig에서 상수는 연산을 컴파일하고 연산 결과를 주어진 변수에 할당할 수 있도록 적절한 크기를 가져야 합니다. 이 경우 code는 u9 타입으로 선언됩니다. 이는 임의의 비트 크기를 가진 변수를 사용할 수 있다는 Zig의 또 다른 근본적 특성입니다. 위 표에서 볼 수 있듯 code가 가질 수 있는 최대값은 256이며, 이를 표현하려면 최소 9비트가 필요합니다. 내장 기능 @as를 사용하면 상수 1을 u9 타입으로 캐스팅할 수 있습니다.
숫자를 비트로 표현하면 훨씬 간단한 방법으로 전체 그리드를 미러링할 수 있습니다.
배열 lines는 각 행을 9비트 정수로 표현하여 전체 그리드를 미러링하며, 각 비트는 행에 있을 수 있는 십진수 숫자를 나타냅니다.
var lines = [_]u9{0} ** 9;
이렇게 하면 9x9 그리드에서 요소의 행 i로 이 배열에 접근하기만 해도, 다음과 같이 숫자의 code와 비트 단위 and( & )를 수행하여 주어진 숫자가 해당 행에 이미 존재하는지 알 수 있습니다.
lines[i] & code
위 연산 결과가 0이면 숫자는 아직 행 i에 존재하지 않는다는 뜻입니다. 그렇지 않으면 중복입니다.
배열 columns는 각 열을 9비트 정수로 표현하여 전체 그리드를 미러링합니다.
var columns = [_]u9{0} ** 9;
이렇게 하면 9x9 그리드에서 요소의 열 j로 이 배열에 접근하기만 해도, 다음과 같이 숫자의 code와 비트 단위 and( & )를 수행하여 주어진 숫자가 해당 열에 이미 존재하는지 알 수 있습니다.
columns[i] & code
위 연산 결과가 0이면 숫자는 아직 열 j에 존재하지 않는다는 뜻입니다. 그렇지 않으면 중복입니다.
예제에서처럼 입력 문자열로 그리드를 채울 때의 빈 Sudoku 그리드를 가정해 봅시다. 빈 요소에 새로 삽입되는 숫자는 새 요소를 포함하는 전체 행, 열 또는 셀에 이미 존재해서는 안 됩니다.
이제 이미 초기화된 다음 그리드를 가정해 봅시다.
_셀_은 굵은 선으로 구분된 아홉 개의 3x3 그리드 각각입니다. 이 시점에서 이해할 핵심은 9x9 그리드의 각 특정 요소에는 그 요소를 포함하는 고유한 행, 열 및 셀이 있다는 것입니다.
예를 들어 그리드의 첫 번째 셀에는 3, 5, 6, 8, 9 값이 들어 있습니다. 따라서 1, 2, 4, 7 값이 빠져 있습니다. 첫 번째 셀의 빈 곳 중 하나에 값 7을 넣으려 한다고 가정해 봅시다. 첫 번째 행의 유일한 빈 요소에는 7을 넣을 수 없습니다. 해당 행에 이미 7이 있기 때문입니다. 첫 번째 열의 유일한 빈 자리에도 7이 이미 있으므로 넣을 수 없습니다. 7은 두 번째 행의 두 빈 요소 중 하나에만 넣을 수 있습니다. 하지만 어느 쪽이 올바른지는 확실히 알 수 없습니다.
이제 1, 5, 7, 9 값을 포함하는 두 번째 셀을 살펴봅시다. 이 셀에서 8을 놓을 수 있는 유일한 위치는 값 7의 오른쪽에 있는 빈 위치, 즉 첫 번째 행임을 알 수 있습니다.
배열 lines와 columns는 행과 열의 중복을 검사합니다. 그러면 셀의 중복을 검사할 새 배열이 필요합니다.
배열 cells는 각 셀을 9비트 정수로 표현하여 전체 그리드를 미러링합니다.
var cells = [_]u9{0} ** 9; // all elements at each cell
여기서부터 일이 더 복잡해집니다. 행이나 열로 cells에 직접 접근할 수 없습니다. cells에 3x3 행렬처럼 접근할 수 있다면 더 쉬울 것입니다. 이는 9x9 행렬에 한 것처럼, 즉 다음과 같이 배열 cell을 채워서 할 수 있습니다.
const cell = fill3x3: { // cell array to allows access
var m : [3][*]u9 = undefined; // cell elements as a matrix,
var pt : [*]u9 = &cells; // cell[cindx[i]][cindx[j]]
for (0..3) |i| { //
m[i] = pt; // stores pointers of each line
pt += 3; // at each position of cell
} //
break :fill3x3 m; // initializes cell with m
}; //
하지만 이제 원래 9x9 그리드 요소의 행과 열에서 cell 행렬의 행과 열을 결정해야 합니다. 행과 열을 3으로 나누는 정수 나눗셈을 사용하여 적절한 인덱스를 얻을 수 있지만, 나눗셈 연산은 악명 높게 느립니다. 두 번의 나눗셈은 더 나쁩니다. 다음 배열을 사용하면 다음과 같이 나눗셈 결과를 얻을 수 있습니다.
const cindx = [_]usize{ 0,0,0, 1,1,1, 2,2,2 };
이렇게 하면 9x9 그리드에서 요소의 행 i와 열 j로 이 행렬에 접근하기만 해도, 다음과 같이 숫자의 code와 비트 단위 and( & )를 수행하여 주어진 숫자가 이 요소의 셀에 이미 존재하는지 알 수 있습니다.
cell[cindx[i]][cindx[j]] & code
위 연산 결과가 0이면 숫자는 아직 셀에 존재하지 않는다는 뜻입니다. 그렇지 않으면 중복입니다.
요소가 중복되었는지에 대한 완전한 테스트는 동일한 행, 열 및 셀에 있는 앞선 모든 요소를 비트 단위 or( | )로 조합하고, 이어서 요소의 code와 비트 단위 and( & )를 수행하여 다음과 같이 할 수 있습니다.
if (((lines[i]|columns[j]|cell[cindx[i]][cindx[j]])&code) != 0) {
unreachable;
}
결과가 0이면 해당 요소가 아직 자신의 행, 열 또는 셀에 존재하지 않기 때문입니다. 결과가 0이 아니면 프로그램은 unreacheable 명령을 실행하려 하므로 중단됩니다. 이것이 Zig에서 실행 오류를 명시적으로 나타내는 가장 간단한 방법입니다. 실제 set 함수의 코드는 오류 발생 위치의 상세 정보도 출력한다는 점에 유의하십시오.
예를 들어 set에 전달하는 문자열에서 첫 번째 '8' 바로 뒤의 '0'를 '5'로 바꾸면 example.zig를 테스트할 때 다음 오류가 발생합니다.
오류 메시지가 말하듯 열 1의 행 3에 이미 5가 있었기 때문입니다. 표시된 대로 오류는
set 함수에서 도달 불가능한 코드에 도달하여 발생한 패닉 때문입니다.
set 함수에서 이중 for 루프는 아래에 나타난 대로 새 요소를 입력 문자열 s에서 그리드로 복사하기 위해 행 단위로 순회합니다(변수 k는 문자열 s에서 새 입력 문자의 인덱스를 유지합니다).
for ( 0..9 ) |i| {
line = matrix[i];
for ( 0..9 ) |j| {
c = @intCast(s[k]-'0');
if (c != 0) {
code = @as(u9,1) << (c-1);
⋮ // rest of the code
}
line[j] = c;
k+= 1;
}
}
문자는 여기서 '0'을 빼서 u4(변수 c)로 변환됩니다. 그리드에 삽입할 새 요소가 0이 아니라면( c != 0 ), 표시된 대로 왼쪽 시프트 명령으로 계산된 code는 해당 미러 그리드와 비트 단위 or( |= )를 수행하여 각 미러 그리드에 복사됩니다. 즉 다음과 같습니다.
lines[i] |= code;
columns[j] |= code;
cell[cindx[i]][cindx[j]] |= code;
시프트 연산이 실행될 때 실행 시간 오버플로가 발생하므로 c 값이 1과 9 사이인지 명시적으로 검사할 필요는 없습니다. 예를 들어 입력 문자열에서 첫 번째 '8' 바로 뒤의 '0'를 ':'로 바꾸면 example.zig를 테스트할 때 다음 오류가 발생합니다.
같은
'0'를 '/'로 바꾸면 유사한 실행 오류가 발생합니다. 값이 1과 9 사이일 때, 즉 입력 그리드가 십진수 숫자만 포함할 때에만 프로그램이 작동합니다.
웹상의 많은 Sudoku 그리드는 '0'을 '.'로도 표현합니다. 이것이 set 함수에 다음 줄이 존재하는 이유입니다.
if (s[k] == '.') c = 0;
c 값이 0이므로 이 코드는 시프트 연산을 편리하게 건너뜁니다.
위 두 섹션에서 보인 강제 오류는 눈에 띄지 않고 지나갔을 수 있는 Zig의 중요한 기능을 보여 줍니다. 하나는 Zig의 견고성입니다. 시프트 연산의 경우 잘못된 동작은 허용되지 않으며, 보인 것처럼 상황은 실행 시간에 포착됩니다.
Zig의 모든 노력이 효율성을 향한다고 생각할 수 있지만, 여기서는 성능이 견고성과 맞바뀐 전형적인 사례입니다. 성능이 궁극적 목표였을 때 이 결정에 대해 복잡한 감정을 가질 수 있습니다. 예를 들어 C에서는 시프트 연산이 비트를 잃는 것이 프로그래머의 문제이며, 이는 이 특정 어셈블러 명령에서 더 나은 성능으로 이어집니다.
위 두 섹션에서 시연된 또 다른 기능은 글의 시작에서 제안했듯 테스트 블록을 프로토타이핑에 사용할 수 있다는 점입니다. 비록 제시된 애플리케이션은 오류 상황에서 특정 경우를 디버그하는 것뿐이었지만 가능성은 아주 많습니다.
이 기능들만으로도 특히 컴파일 언어에서는 매우 드문, 놀라운 힘을 보여 줍니다.
이 모든 것은 매우 놀랍고, 이전에는 인터프리터 언어에서만 발견되던 많은 장점이 더 높은 성능을 제공하기 위해 점차 컴파일 언어로 이동하고 있다고 생각하게 합니다. [여기서 Mojo에 대한 언급이 적절해 보입니다].
특히 컴파일 시간 실행이라는 개념에서 Zig가 인터프리터 언어와 닮은 점은 매우 두드러지지만, 안타깝게도 이 글에서는 충분히 강조되지 않았습니다. 이는 한편으로 Zig를 특별히 다르고 강력하게 만들지만, 다른 한편으로 이해하기 어렵게 만드는 측면입니다.
저는 언어를 빠르고 쉽게 시작하는 방법과 Zig 언어를 멋지게 만드는 단순한 측면에 더 집중했습니다. 여기서 언급하지 않은 다른 측면들도 많으며, 그 역시 매우 인상적입니다.
여기에 제시된 예제들은 Java와 C로도 개발된, Sudoku 그리드를 푸는 더 복잡한 프로그램의 단순화된 버전입니다. 이 저장소의 문서는 이를 수행하는 데 사용된 대부분의 구조와 알고리즘을 자세히 설명합니다.