c++ - 在程序上包括图形界面

就像标题说的那样，我认为我的一个包含项存在问题。

我是个学生，我的老师给了我一个创建名为EZ-Draw的可视界面(由他自己编码)的解决方案。

但是在我的代码中的某个地方存在一个问题，因为我的编译器告诉我许多这种样式的错误:

|364|undefined reference to `CreateCompatibleDC@4'|
|559|undefined reference to `SelectObject@8'|
...

我的代码:

解释器

#ifndef INTERPRETEUR_HPP_INCLUDED
#define INTERPRETEUR_HPP_INCLUDED
#include <sstream>
#include <map>
#include <math.h>
#include "Pile_Template.hpp"
#include "ez-draw++.h"

#define PI 3.14159265

class Interpreteur {
private:
    void (Interpreteur::*ptr)();
    EZWindow myWindow;
    Pile<double> pile;
    Pile<string> pilestr;
    bool run;
public:
    map<string,void(Interpreteur::*)()> myMap;
    Interpreteur();
    ~Interpreteur();
    inline bool getRun() {return run;};
    inline void setEmpilerPile(double nombre) {pile.empiler(nombre);};
    template <typename T>
        string itos(T nombre) // convertit un double en string
        {
            ostringstream ss;
            ss<<nombre;
            return ss.str();
        }
    void addition();
    void moins();
    void multiplie();
    void divise();
    void quit();
    void push();
    void pushstr();
    void pop();
    void popstr();
    void copy();
    void copystr();
    void print();
    void printstr();
    void display();
    void displaystr();
    void count();
    void countstr();
    void swap();
    void swapstr();
    void sinus();
    void cosinus();
    void tangente();
    void racine();
    void trunc();
    void line();
    void color();
    void drawstr();
    void triangle();
    void rectangle();
    void circle();

};
#endif // SOUS_PROGRAMMES_HPP_INCLUDED

解释器

#include "interpreteur.hpp"
#include <sstream>
#include <map>
#include <math.h>
#include <string>

using namespace std;


void Interpreteur::addition()
{
    pile.empiler(pile.depiler()+pile.depiler());
}

void Interpreteur::moins()
{
    double nombre=pile.depiler();
    nombre=pile.depiler()-nombre;
    pile.empiler(nombre);
}

void Interpreteur::multiplie()
{
    pile.empiler(pile.depiler()*pile.depiler());
}

void Interpreteur::divise()
{
    double nombre=pile.depiler();
    nombre=pile.depiler()/nombre;
    pile.empiler(nombre);
}

void Interpreteur::quit()
{
    run=false;
}

void Interpreteur::push()
{
    double i;
    cin>>i;
    pile.empiler(i);
}

void Interpreteur::pushstr()
{
    string chaine;
    char merde;
    cin>>merde;
    if(merde=='"')
    {
        getline(cin,chaine,'"');
        pilestr.empiler(chaine);
    }
    else
    {
        cin.putback(merde);
        cerr<<"mauvaise chaine de caractères"<<endl;
    }
}

void Interpreteur::pop()
{
    pile.depiler();
}

void Interpreteur::popstr()
{
    pilestr.depiler();
}

 void Interpreteur::copy()
{
   int i=pile.depiler();
    pile.empiler(pile[pile.getSommet()-i]);
}

void Interpreteur::copystr()
{
    int i=pile.depiler();
    pilestr.empiler(pilestr[pile.getSommet()-i]);
}

void Interpreteur::print()
{
    cout<<pile.depiler()<<endl;
}

void Interpreteur::printstr()
{
    cout<<pilestr.depiler()<<endl;
}

void Interpreteur::display()
{
    pile.afficher(cout);
}

void Interpreteur::displaystr()
{
    pilestr.afficher(cout);
}

void Interpreteur::count()
{
    pile.empiler(pile.getSommet());
}

void Interpreteur::countstr()
{
    pilestr.empiler(itos(pilestr.getSommet()));
}

void Interpreteur::swap()
{
    double first=pile.depiler();
    double second=pile.depiler();
    pile.empiler(first);
    pile.empiler(second);
}

void Interpreteur::swapstr()
{
    string first=pilestr.depiler();
    string second=pilestr.depiler();
    pilestr.empiler(first);
    pilestr.empiler(second);
}

void Interpreteur::sinus()
{
    pile.empiler(sin(pile.depiler()*PI/180));
}

void Interpreteur::cosinus()
{
    pile.empiler(cos(pile.depiler()*PI/180));
}

void Interpreteur::tangente()
{
    pile.empiler(tan(pile.depiler()*PI/180));
}

void Interpreteur::racine()
{
    pile.empiler(sqrt(pile.depiler()));
}

void Interpreteur::trunc()
{
    int x=pile.depiler();
    pile.empiler(x);
}

void Interpreteur::line()
{
    int y2=pile.depiler();
    int x2=pile.depiler();
    int y1=pile.depiler();
    int x1=pile.depiler();
    myWindow.drawLine(x1,y1,x2,y2);
}

void Interpreteur::color()
{
    int couleur=pile.depiler();
    switch(couleur)
    {
        case 1:{myWindow.setColor(ez_black);break;}
        case 2:{myWindow.setColor(ez_red);break;}
        case 3:{myWindow.setColor(ez_green);break;}
        case 4:{myWindow.setColor(ez_blue);break;}
        case 5:{myWindow.setColor(ez_cyan);break;}
        case 6:{myWindow.setColor(ez_magenta);break;}
        case 7:{myWindow.setColor(ez_yellow);break;}
        //pourquoi que on a pas fait le gris ? ez_grey
        default:{pile.empiler(couleur); cerr<<"couleur inconnue"<<endl; break;}
    }
    // COULEUR : ez_black, ez_white, ez_grey, ez_red, ez_green, ez_blue,ez_yellow, ez_cyan, ez_magenta

}

void Interpreteur::drawstr()
{
    string str=pilestr.depiler();
    int y1=pile.depiler();
    int x1=pile.depiler();
    myWindow.drawText(EZ_MC,x1,y1,str);
}

void Interpreteur::triangle()
{
    int y3=pile.depiler();
    int x3=pile.depiler();
    int y2=pile.depiler();
    int x2=pile.depiler();
    int y1=pile.depiler();
    int x1=pile.depiler();
    myWindow.drawTriangle(x1,y1,x2,y2,x3,y3);
}

void Interpreteur::rectangle()
{
    int y2=pile.depiler();
    int x2=pile.depiler();
    int y1=pile.depiler();
    int x1=pile.depiler();
    myWindow.drawRectangle(x1,y1,x2,y2);
}

void Interpreteur::circle()
{
    int y2=pile.depiler();
    int x2=pile.depiler();
    int y1=pile.depiler();
    int x1=pile.depiler();
    myWindow.drawCircle(x1,y1,x2,y2);
}

Interpreteur::Interpreteur()
{
    run=true;
    myMap["+"]=&Interpreteur::addition;
    myMap["-"]=&Interpreteur::moins;
    myMap["*"]=&Interpreteur::multiplie;
    myMap["/"]=&Interpreteur::divise;
    myMap["exit"]=&Interpreteur::quit;
    myMap["push"]=&Interpreteur::push;
    myMap["pushstr"]=&Interpreteur::pushstr;
    myMap["pop"]=&Interpreteur::pop;
    myMap["popstr"]=&Interpreteur::popstr;
    myMap["copy"]=&Interpreteur::copy;
    myMap["copystr"]=&Interpreteur::copystr;
    myMap["print"]=&Interpreteur::print;
    myMap["printstr"]=&Interpreteur::printstr;
    myMap["display"]=&Interpreteur::display;
    myMap["displaystr"]=&Interpreteur::displaystr;
    myMap["count"]=&Interpreteur::count;
    myMap["countstr"]=&Interpreteur::countstr;
    myMap["swap"]=&Interpreteur::swap;
    myMap["swapstr"]=&Interpreteur::swapstr;
    myMap["sin"]=&Interpreteur::sinus;
    myMap["cos"]=&Interpreteur::cosinus;
    myMap["tan"]=&Interpreteur::tangente;
    myMap["sqrt"]=&Interpreteur::racine;
    myMap["trunc"]=&Interpreteur::trunc;
    myMap["line"]=&Interpreteur::line;
    myMap["color"]=&Interpreteur::color;
    myMap["drawstr"]=&Interpreteur::drawstr;
    myMap["triangle"]=&Interpreteur::triangle;
    myMap["rectangle"]=&Interpreteur::rectangle;
    myMap["circle"]=&Interpreteur::circle;
}

Interpreteur::~Interpreteur()
{
    map<string, void (Interpreteur::*)()>::iterator it;
    myMap.erase(it);
}

这是我老师给的"EZ-Draw documentation"，以了解ez-draw和ez-draw++
我不明白编译器要告诉我什么

最佳答案

您正在使用来自C++的C函数，为此，您需要明确告诉编译器它们是C函数。从C++使用的C头文件应包含可在C++中使用的行:

#ifdef __cplusplus
extern "C" {
#endif

//The header file which declares the functions which are not linked correctly here

#ifdef __cplusplus
}
#endif

一点解释:
对于C和C++，“名称修改”函数是不同的，因为在C++中，您可以重载一个函数的名称，但单独的函数名称并不能唯一地标识一个函数，因此编译器在编译时会在后台为函数名称添加一些符号使这些名称唯一(即DC@4中的CreateCompatibleDC@4)。

由于您的链接器需要C++函数，因此它将搜索CreateCompatibleDC@4，但是您的某些文件在C中进行了编译，并导出了一个名为CreateCompatible的函数，这就是为什么您会获得“ undefined reference ”的原因:链接器告诉您无法找到定义一些功能。