warum gibt der linker einen Fehler aus?

fairy2211

Hallo,

Ich versuche einen bytecode interpreter zu schreiben. Mein Linker findet "write_constant()" nicht, obwohl sie verschachtelt als include enthalten ist. Kann mir jemand erklären wieso der linker meckert? Hier sind die wichtigen Dateien:

#ifndef GUARD_DEBUG_h
#define GUARD_DEBUG_h
#include "utils.h"
#include <iostream>

void disassemble_instruction(op_code instruction);

void disassemble_code_segment(code_segment& segment);

uint64_t write_constant(Value constant, constant_segment& const_segment);

#endif

#ifndef TEST_DEBUG_h
#define TEST_DEBUG_h
#include "debug.h"
#include "utils.h"
#include <assert.h>

int test_disassemble_code_segment();
// write_constant taucht nur hier einmal auf.
int test_disassemble_const_segment();

#endif

#include "test_debug.h"
#include "debug.h"
using namespace std;

int test_disassemble_const_segment() {
    cout << "############ testing disassemble_const_segment ############" << endl;
    constant_segment segment;
    write_constant(2, segment);
    write_constant(5, segment);
    write_constant(28, segment);
    
    for (constant_segment::iterator it = segment.begin(); it != segment.end(); it++){
        std::cout << *it << std::endl;
    }
    return 0;
}

#include "test_debug.h"
#include "debug.h"
#include "utils.h"
#include <vector>
using namespace std;

int main(){
    test_disassemble_code_segment();
    test_disassemble_const_segment();
    return 0;
}

SeppJ

Mir geht es wie dem Linker: Ich sehe keine Implementierung von write_constant. Wo meinst du, soll die sein?

uint64_t write_constant(Value constant, constant_segment& const_segment);

Dies ist sie nicht. Dies ist bloß eine Bekanntmachung, dass es irgendwo eine Funktion mit dieser Signatur gibt. Aber wo ist sie?

PS: Losgelöst von deinem Problem:

    constant_segment segment;
    write_constant(2, segment);

Das sieht sehr nach C mit cout statt nach C++ aus. Soll constant_segment vielleicht eher eine Klasse mit einer Methode write_constant sein?

fairy2211

Ich habe mit Absicht keine klasse gemacht, die klasse ist nämlich ein vector<Double> bzw vector<op_code> wobei op_code ein enum ist. Die implementierung von write_constant ist in der zugehörigen debug.cpp datei, ich habe sie ausgelassen weil ich dachte ihr nehmt an ich hätte das richtig gemacht.

#include "debug.h"
using namespace std;

void disassemble_instruction(op_code instruction){
    switch (instruction) {
        case OP_RETURN:
            cout << "OP_RETURN" << endl;
    }
}

void disassemble_code_segment(code_segment& segment){
    for (code_segment::iterator it = segment.begin(); it != segment.end(); it++) {
        cout << *it << endl;
    }
}

uint64_t write_constant(Value constant, constant_segment& const_segment){
    const_segment.emplace_back(constant);
    return const_segment.size()-1;
}

Th69

Und was verwendest du als Buildsystem (IDE, CMake, Makefile, ...)?
Hast du dort auch die "Debug.cpp" zum Kompilieren (und Linken) hinzugefügt?

PS: Debug ist aber ein eigenartiger Name für einen Bytecode-Interpreter...

fairy2211

debug enthält methoden, die sachen auslesen wie ein debugger. das sollen verschiedene module sein. ich habe tatsächlich eine datei im makefile nicht aktualisiert. bitte entschuldigt die frage!

SeppJ

@fairy2211 sagte in warum gibt der linker einen Fehler aus?:

Ich habe mit Absicht keine klasse gemacht, die klasse ist nämlich ein vector<Double> bzw vector<op_code> wobei op_code ein enum ist.

Auch mit vector kann man C mit cout schreiben

Du hast doch offensichtlich irgendein Konzept von einem Codesegment, das bestimmte Dinge enthält und bestimmte Invarianten garantiert. Der vector alleine erfüllt das offenbar nicht, denn sonst bräuchtest du ja nicht deine Zusatzfunktionen. Aber nun muss der Nutzer wissen, dass er nur deine Zusatzfunktionen für die Manipulation dieses Vectors nutzen darf, weil er sonst ggf. die erwarteten Invarianten verletzt. In C (und bei dir jetzt) ist das halt Sache des Nutzers, dass er davon wissen muss, aber in C++ gibt es ein eingebautes Mittel, um die Daten mit ihren Funktionen zu verbinden, nämlich class, so dass man nicht (so einfach) versehentlich Fehler macht.

fairy2211

du hast schon recht vielleicht refactore ich alles. Danke!