C Academy · Pelajaran

Menambahkan Variabel

Simpan dan panggil kembali nilai.

Menambahkan Variabel adalah pelajaran C Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C Academy mencakup 4 pelajaran total.

Melampaui Aritmetika

Untuk mendukung x = 5 dan kemudian x + 1, interpreter memerlukan identifier serta tempat untuk menyimpan nilainya. Tempat penyimpanan itu disebut lingkungan.

Kita akan memperluas lexer, parser, dan evaluator agar dapat menangani nama serta penugasan.

Melakukan Lexing Identifier

Identifier diawali huruf atau garis bawah, lalu dilanjutkan dengan huruf, digit, atau garis bawah. Kita menyalin nama tersebut ke dalam token.

Buffer berukuran tetap membuat contoh ini tetap sederhana; lexer nyata biasanya menginternalkan nama.

#include <ctype.h>
#include <string.h>

typedef struct { TokKind kind; int value; char name[32]; } Token;

static Token lex_ident(void) {
  Token t; t.kind = TOK_IDENT; int i = 0;
  while (isalnum((unsigned char)peek()) || peek() == '_')
    if (i < 31) t.name[i++] = advance(); else advance();
  t.name[i] = '\0';
  return t;
}

Simpul Variabel

AST memperoleh dua jenis simpul: referensi variabel dan penugasan. Masing-masing menyimpan nama variabel.

Penugasan juga menyimpan ekspresi yang nilainya akan disimpan.

typedef struct Node {
  enum { N_NUM, N_BINOP, N_VAR, N_ASSIGN } kind;
  int value; char op; char name[32];
  struct Node *left, *right;  /* assign uses right as value expr */
} Node;

Lingkungan

Lingkungan memetakan nama ke nilai. Array linear sederhana yang berisi pasangan nama/nilai sudah cukup untuk interpreter kecil.

Bahasa yang lebih besar menggunakan tabel hash untuk pencarian O(1) dan cakupan bertingkat.

#define MAX_VARS 64

typedef struct {
  char names[MAX_VARS][32];
  int  values[MAX_VARS];
  int  count;
} Env;

static Env env;  /* global for this tiny example */

Menetapkan Variabel

Penugasan dapat memperbarui slot yang sudah ada atau menambahkan slot baru. Pencarian linear membuat kode tetap singkat.

Mengembalikan nilai yang disimpan memungkinkan penugasan digunakan sebagai ekspresi, seperti y = (x = 3).

#include <string.h>

static int env_set(const char *name, int v) {
  for (int i = 0; i < env.count; i++)
    if (strcmp(env.names[i], name) == 0) {
      env.values[i] = v; return v;
    }
  strcpy(env.names[env.count], name);
  env.values[env.count] = v;
  env.count++;
  return v;
}

Membaca Variabel

Pencarian memindai nama lalu mengembalikan nilainya. Mereferensikan variabel yang belum ditentukan merupakan kesalahan saat runtime.

Menangkapnya di sini menghasilkan pesan yang jelas, bukan nilai sampah.

#include <stdio.h>
#include <stdlib.h>

static int env_get(const char *name) {
  for (int i = 0; i < env.count; i++)
    if (strcmp(env.names[i], name) == 0)
      return env.values[i];
  fprintf(stderr, "undefined variable: %s\n", name);
  exit(1);
}

Mengurai Penugasan

Penugasan memiliki prioritas paling rendah dan bersifat asosiatif-kanan. Kita mengurai sebuah faktor; jika faktor tersebut merupakan identifier tunggal yang diikuti =, kita membangun simpul assign.

Jika tidak, identifier tersebut hanya merupakan pembacaan variabel.

static Node *parse_assign(void) {
  if (cur().kind == TOK_IDENT) {
    char saved[32]; strcpy(saved, cur().name);
    bump();
    if (cur().kind == TOK_ASSIGN) {
      bump();
      Node *val = parse_assign();
      return assign_node(saved, val);
    }
    return var_node(saved);  /* not an assignment */
  }
  return parse_expr();
}

Mengevaluasi Variabel

Evaluator memperoleh dua kasus baru. Simpul variabel mencari namanya di lingkungan; simpul assign mengevaluasi ekspresi nilainya lalu menyimpannya.

Keduanya menggunakan kembali pembantu env_get dan env_set.

int eval(Node *n) {
  switch (n->kind) {
    case N_NUM:    return n->value;
    case N_VAR:    return env_get(n->name);
    case N_ASSIGN: return env_set(n->name, eval(n->right));
    case N_BINOP: {
      int l = eval(n->left), r = eval(n->right);
      switch (n->op) {
        case '+': return l + r; case '-': return l - r;
        case '*': return l * r; case '/': return l / r;
      }
    }
  }
  return 0;
}

Satu Langkah REPL yang Berfungsi

Program ini menyimpan sebuah variabel, lalu membacanya kembali dalam sebuah ekspresi—semuanya melalui lingkungan. Program ini memodelkan satu baris dari interpreter nyata.

Jalankan untuk melihat penugasan dan pencarian bekerja sama.

#include <stdio.h>
#include <string.h>

#define MAX_VARS 64
static char names[MAX_VARS][32];
static int  values[MAX_VARS];
static int  count;

static int env_set(const char *n,int v){
  for(int i=0;i<count;i++) if(!strcmp(names[i],n)){values[i]=v;return v;}
  strcpy(names[count],n); values[count]=v; count++; return v;
}
static int env_get(const char *n){
  for(int i=0;i<count;i++) if(!strcmp(names[i],n)) return values[i];
  return 0;
}

int main(void){
  env_set("x", 5);            /* x = 5 */
  int r = env_get("x") + 1;   /* x + 1 */
  printf("x = %d\n", env_get("x"));
  printf("x + 1 = %d\n", r);
  return 0;
}

Cakupan dan Pembayangan

Satu lingkungan datar bersifat global. Bahasa nyata menambahkan cakupan bertingkat agar variabel lokal suatu fungsi tidak menimpa nama di luar cakupannya.

Anda mengimplementasikannya dengan merangkai lingkungan: pencarian berjalan dari cakupan terdalam ke arah luar.

typedef struct Env {
  char names[MAX_VARS][32];
  int  values[MAX_VARS];
  int  count;
  struct Env *parent;  /* enclosing scope */
} Env;

Langkah Berikutnya

Setelah variabel tersedia, Anda dapat menambahkan pernyataan, kondisional, dan fungsi. Masing-masing merupakan jenis simpul baru beserta kasus eval.

Mulai dari sini, pipeline lexer-parser-evaluator yang sama dapat berkembang menjadi bahasa kecil yang nyata.

Pemeriksaan Singkat

Pikirkan tanggung jawab lingkungan.

Ringkasan

Anda telah menambahkan identifier ke lexer, simpul var/assign ke AST, lingkungan dengan operasi set dan get, serta kasus eval untuk pembacaan dan penugasan.

Interpreter kini mengingat keadaan—fondasi untuk pernyataan dan fungsi.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menambahkan Variabel” gratis?

Ya — teks lengkap “Menambahkan Variabel” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C Academy, upgrade ke CoddyKit PRO. Kursus C Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menambahkan Variabel”?

Simpan dan panggil kembali nilai. Kamu berlatih C Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai C Academy?

Tidak diperlukan pengalaman sebelumnya. C Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Menambahkan Variabel” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran C Academy ini?

Ya. Setiap pelajaran C Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke C Academy