Variabelen toevoegen
Sla waarden op en haal ze terug.
Variabelen toevoegen is een gratis C Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C Academy bevat in totaal 4 lessen.
Verder dan rekenkundige bewerkingen
Voor ondersteuning van x = 5 en later x + 1 heeft de interpreter identifiers nodig en een plaats om hun waarden op te slaan. Die opslag is de omgeving.
We breiden de lexer, parser en evaluator uit om namen en toewijzingen te verwerken.
Identifiers lexen
Een identifier begint met een letter of onderstrepingsteken en gaat verder met letters, cijfers of onderstrepingstekens. We kopiëren de naam naar het token.
Een buffer met vaste grootte houdt het voorbeeld eenvoudig; echte lexers maken namen intern.
#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;
}Een variabelenode
De AST krijgt twee nodetypen: een verwijzing naar een variabele en een toewijzing. Beide slaan de naam van de variabele op.
Een toewijzing bewaart ook de expressie waarvan de waarde wordt opgeslagen.
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;De omgeving
De omgeving koppelt namen aan waarden. Voor een kleine interpreter volstaat een eenvoudige lineaire array met naam-waardeparen.
Grotere talen gebruiken hashtabellen voor opzoeken in O(1) en geneste bereiken.
#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 */Een variabele instellen
Een toewijzing werkt een bestaand slot bij of voegt een nieuw slot toe. Lineair zoeken houdt de code kort.
Door de opgeslagen waarde te retourneren, kunnen toewijzingen als expressies worden gebruikt, zoals 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;
}Een variabele lezen
Bij het opzoeken wordt naar de naam gezocht en de waarde ervan geretourneerd. Verwijzen naar een niet-gedefinieerde variabele is een runtimefout.
Als je dit hier opvangt, krijg je een duidelijke melding in plaats van een onzinnige waarde.
#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);
}Een toewijzing parsen
Toewijzing heeft de laagste prioriteit en is rechtsassociatief. We parsen een factor; als dit een los identifier is gevolgd door =, bouwen we een assign-node.
Anders wordt de identifier alleen gelezen als variabele.
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();
}Variabelen evalueren
De evaluator krijgt twee gevallen erbij. Een variabelenode zoekt de naam op in de omgeving; een assign-node evalueert zijn waarde-expressie en slaat die op.
Beide hergebruiken de helpers env_get en 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;
}Een werkende REPL-stap
Dit programma slaat een variabele op en leest die daarna terug in een expressie — volledig via de omgeving. Het modelleert één regel van een echte interpreter.
Voer het uit om te zien hoe toewijzing en opzoeken samenwerken.
#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;
}Bereiken en verbergen
Eén platte omgeving is globaal. Echte talen voegen geneste bereiken toe, zodat lokale variabelen van een functie namen in buitenliggende bereiken niet overschrijven.
Je implementeert dit door omgevingen aan elkaar te koppelen: bij het opzoeken ga je van het binnenste bereik naar buiten.
typedef struct Env {
char names[MAX_VARS][32];
int values[MAX_VARS];
int count;
struct Env *parent; /* enclosing scope */
} Env;Hoe je verdergaat
Nu er variabelen zijn, kun je instructies, voorwaarden en functies toevoegen. Elk daarvan is een nieuw nodetype plus een eval-geval.
Vanaf hier kan dezelfde lexer-parser-evaluator-pijplijn uitgroeien tot een echte kleine taal.
Korte controle
Denk na over waarvoor de omgeving verantwoordelijk is.
Samenvatting
Je hebt identifiers aan de lexer toegevoegd, var- en assign-nodes aan de AST, een omgeving met set en get, en eval-gevallen voor lezen en toewijzen.
De interpreter onthoudt nu toestand — de basis voor instructies en functies.
Leer C met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 39
- Lessen
- 144
Veelgestelde vragen
Is de les “Variabelen toevoegen” gratis?
Ja — de volledige tekst van “Variabelen toevoegen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C Academy bevat in totaal 4 lessen.
Wat leer ik in “Variabelen toevoegen”?
Sla waarden op en haal ze terug. Je oefent met C Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met C Academy te beginnen?
Ervaring vooraf is niet nodig. C Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Variabelen toevoegen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over C Academy?
Ja. Elke les over C Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Invoer tokeniseren
- Expressies parsen
- De boom evalueren
- Variabelen toevoegen