使用C++编写自己的编程语言CASM

最新推荐文章于 2024-04-23 04:33:05 发布
最新推荐文章于 2024-04-23 04:33:05 发布
阅读量616 收藏 4
点赞数 1
分类专栏： CASM 文章标签： c++ 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cgy091107/article/details/132621823
版权

CASM帮助文档：

0.注释:用于在代码中添加注释。注释不会被执行，只是对代码的解释说明。 
    ;注释内容 
1.FUNC:通过这个指令，你可以定义一个可以被跳转的代码区块。
    FUNC [NAME]     
    *结束标记：另一个函数或文件结束 
2.TYPE:这个指令用于标明要保存的数据的类型。 
    TYPE [INT（高精整数） | STR（字符串） | BOOL（布尔值） | DOUBLE（双精度浮点数） | FLOAT（浮点数） | CHAR（字符）] 
3.PUSH:这个指令用于将数据推入栈顶。 
    PUSH [DATA] 
4.OUT:用于将栈顶的数据输出。
    OUT 
5.ENDL:用于输出一个换行符。 
    ENDL 
6.PUSHCOMMENT:将一个分号字符";"推入字符栈的栈顶。 
    PUSHCOMMENT 
7.POP:从栈中移除栈顶元素。 
    POP 
8.ADD:取出栈顶的元素，与下一个栈顶元素相加，并将结果推回栈顶。对于布尔类型，加法表示逻辑“或”操作。 
    ADD 
9.SUB:取出栈顶的元素，与下一个栈顶元素相减，并将结果推回栈顶。对于布尔类型，减法表示逻辑“异或”操作。对于字符串类型，减法会导致错误。 
    SUB 
10.MUL:取出栈顶的元素，与下一个栈顶元素相乘，并将结果推回栈顶。对于布尔类型，乘法表示逻辑“与”操作。对于字符串类型，乘法会导致错误。 
    MUL 
11.DIV:取出栈顶的元素，与下一个栈顶元素相除，并将结果推回栈顶。字符串、布尔类型或字符类型无法进行除法操作。 
    DIV 
12.MOD: 取出栈顶的元素，与下一个栈顶元素进行取模运算，并将结果推回栈顶。仅适用于整数类型。 
    MOD 
13.IN:从输入中读取一个变量的值，并将其推入栈顶。 
    IN 
14.VAR:声明一个变量。 
    VAR [NAME] 
15.GETVAR:查找名为 [VARNAME] 的变量，然后将其值赋给栈顶元素，并弹栈。 
    GETVAR [VARNAME] 
16.PUSHVAR:将变量推入栈顶。 
    PUSHVAR [VARNAME] 
17.IFE:比较栈顶元素与次栈顶元素是否相等，如果相等，将真值推入布尔栈。 
    IFE 
18.IFB:比较栈顶元素与次栈顶元素，判断是否栈顶元素较大，如果是，将真值推入布尔栈。 
    IFB 
19.IFS:比较栈顶元素与次栈顶元素，判断是否次栈顶元素较大，如果是，将真值推入布尔栈。
    IFS 
20.GOTO:跳转到指定的代码块。 
    GOTO [NAME] 
21.IF: 如果布尔栈的栈顶为真，跳转到指定标签。如果标签是 "RET"，函数将退出。
     IF [NAME] 
22.EXIT:退出整个程序。 
    EXIT 
23.RAND: 将一个指定范围内的随机整数推入整数栈。 
    RAND [NUM1] [NUM2]    
     *从 NUM1 开始，到 NUM1+NUM2 结束 
24.CLEAR: 清空栈中的所有数据。 
    CLEAR 
25.NOT:对布尔栈顶进行“非”运算。 
    NOT

CASM解释器讲解视频：

我独自开发了一种编程语言：CASM

CASM解释器源代码（剪贴板有问题，总是粘贴成一行，哪位大佬帮帮我……）：

#include <iostream>
#include <cstring>
#include <string>
#include <cstdio>
#include <map>
#include <queue>
#include <stack>
#include <cstdlib>
#include <list>
#include "hint.hpp"
using namespace std;

map<string, list<string>> codes;
map<string, HyperInt> intVar;
map<string, string> stringVar;
map<string, bool> boolVar;
map<string, double> doubleVar;
map<string, float> floatVar;
map<string, unsigned char> charVar;
stack<HyperInt> intData;
stack<string> stringData;
stack<bool> boolData;
stack<double> doubleData;
stack<float> floatData;
stack<unsigned char> charData;
int nowType;//0:int,1:string,2:bool,3:double,4:float,5:char

struct Lines {
    string op;
    string params[25];

    Lines() {
        op = "";
        memset(params, 0, sizeof(params));
        strData = "";
    }
    int len = -1;
    string strData;
    /* ABOUT LEN:
     *  -1: AN EMPTY LINE;
     *  0:OPERATOR ONLY;
     *  N:OPERATOR WITH N PARAMETERS.
     */
};

Lines analysisLine(const string &line);

void knifeCode();

void runCode(const string &name);

void setType(const string &type) {
    if (type == "INT") {
        nowType = 0;
    } else if (type == "STR") {
        nowType = 1;
    } else if (type == "BOOL") {
        nowType = 2;
    } else if (type == "DOUBLE") {
        nowType = 3;
    } else if (type == "FLOAT") {
        nowType = 4;
    } else if (type == "CHAR") {
        nowType = 5;
    } else {
        cout << "ERR:UnKnow Type.";
        exit(1);
    }
}

void push(Lines &line) {
    try {
        if (nowType == 0) {
            HyperInt data = 0;
            for (char i: line.params[0]) {
                data = data * 10;
                data = data + i - '0';
            }
            intData.push(data);

        } else if (nowType == 1) {
            stringData.push(line.strData);
        } else if (nowType == 2) {
            boolData.push(line.params[0] != "FALSE");
        } else if (nowType == 3) {
            doubleData.push(stod(line.params[0]));//stod:string to double
        } else if (nowType == 4) {
            floatData.push(stof(line.params[0]));//stof:string to float
        } else {
            charData.push(line.params[0][0]);
        }
    } catch (exception &e) {
        cout << "ERROR: Type error.";
        exit(1);
    }
}

void out() {
    if (nowType == 0) {
        cout << intData.top();
        intData.pop();
    } else if (nowType == 1) {
        cout << stringData.top();
        stringData.pop();
    } else if (nowType == 2) {
        cout << boolData.top();
        boolData.pop();
    } else if (nowType == 3) {
        cout << doubleData.top();
        doubleData.pop();
    } else if (nowType == 4) {
        cout << floatData.top();
        floatData.pop();
    } else {
        cout << charData.top();
        charData.pop();
    }
}

void endLine() {
    cout << endl;
}

void pushComment() {
    charData.push(';');
}

void pop() {
    if (nowType == 0) {
        intData.pop();
    } else if (nowType == 1) {
        stringData.pop();
    } else if (nowType == 2) {
        boolData.pop();
    } else if (nowType == 3) {
        doubleData.pop();
    } else if (nowType == 4) {
        floatData.pop();
    } else {
        charData.pop();
    }
}

void add() {
    if (nowType == 0) {
        HyperInt a = intData.top();
        intData.pop();
        HyperInt b = intData.top();
        intData.pop();
        intData.push(a + b);
    } else if (nowType == 1) {
        string a = stringData.top();
        stringData.pop();
        string b = stringData.top();
        stringData.pop();
        stringData.push(a + b);
    } else if (nowType == 2) {
        bool a = boolData.top();
        boolData.pop();
        bool b = boolData.top();
        boolData.pop();
        boolData.push(a || b);
    } else if (nowType == 3) {
        double a = doubleData.top();
        doubleData.pop();
        double b = doubleData.top();
        doubleData.pop();
        doubleData.push(a + b);
    } else if (nowType == 4) {
        float a = floatData.top();
        floatData.pop();
        float b = floatData.top();
        floatData.pop();
        floatData.push(a + b);
    } else {
        int a = (int) charData.top();
        charData.pop();
        int b = (int) charData.top();
        charData.pop();
        charData.push((char) (a + b));
    }

}

void sub() {
    if (nowType == 0) {
        HyperInt a = intData.top();
        intData.pop();
        HyperInt b = intData.top();
        intData.pop();
        intData.push(a - b);
    } else if (nowType == 1) {
        cout << "TypeError.";
        exit(1);
    } else if (nowType == 2) {
        bool a = boolData.top();
        boolData.pop();
        bool b = boolData.top();
        boolData.pop();
        boolData.push(a ^ b);
    } else if (nowType == 3) {
        double a = doubleData.top();
        doubleData.pop();
        double b = doubleData.top();
        doubleData.pop();
        doubleData.push(a - b);
    } else if (nowType == 4) {
        float a = floatData.top();
        floatData.pop();
        float b = floatData.top();
        floatData.pop();
        floatData.push(a - b);
    } else {
        int a = (int) charData.top();
        charData.pop();
        int b = (int) charData.top();
        charData.pop();
        charData.push((char) (a - b));
    }
}

void mul() {
    if (nowType == 0) {
        HyperInt a = intData.top();
        intData.pop();
        HyperInt b = intData.top();
        intData.pop();
        intData.push(a * b);
    } else if (nowType == 1) {
        cout << "TypeError.";
        exit(1);
    } else if (nowType == 2) {
        bool a = boolData.top();
        boolData.pop();
        bool b = boolData.top();
        boolData.pop();
        boolData.push(a && b);
    } else if (nowType == 3) {
        double a = doubleData.top();
        doubleData.pop();
        double b = doubleData.top();
        doubleData.pop();
        doubleData.push(a * b);
    } else if (nowType == 4) {
        float a = floatData.top();
        floatData.pop();
        float b = floatData.top();
        floatData.pop();
        floatData.push(a * b);
    } else {
        int a = (int) charData.top();
        charData.pop();
        int b = (int) charData.top();
        charData.pop();
        charData.push((char) (a * b));
    }
}

void div() {
    if (nowType == 0) {
        HyperInt a = intData.top();
        intData.pop();
        HyperInt b = intData.top();
        intData.pop();
        intData.push(a / b);
    } else if (nowType == 3) {
        double a = doubleData.top();
        doubleData.pop();
        double b = doubleData.top();
        doubleData.pop();
        doubleData.push(a / b);
    } else if (nowType == 4) {
        float a = floatData.top();
        floatData.pop();
        float b = floatData.top();
        floatData.pop();
        floatData.push(a / b);
    } else {
        cout << "TypeError.";
        exit(1);
    }
}

void mod() {
    if (nowType == 0) {
        HyperInt a = intData.top();
        intData.pop();
        HyperInt b = intData.top();
        intData.pop();
        intData.push(a % b);
    } else {
        cout << "TypeError.";
        exit(1);
    }
}

void casmIn() {
    if (nowType == 0) {
        HyperInt a;
        cin >> a;
        intData.push(a);
    } else if (nowType == 1) {
        string a;
        stringData.push(a);
    } else if (nowType == 2) {
        bool a;
        cin >> a;
        boolData.push(a);
    } else if (nowType == 3) {
        double a;
        cin >> a;
        doubleData.push(a);
    } else if (nowType == 4) {
        float a;
        cin >> a;
        floatData.push(a);
    } else {
        char a;
        cin >> a;
        charData.push(a);
    }
}

void var(const string &varName) {
    if (nowType == 0) {
        intVar[varName] = 0;
    } else if (nowType == 1) {
        stringVar[varName] = "";
    } else if (nowType == 2) {
        boolVar[varName] = false;
    } else if (nowType == 3) {
        doubleVar[varName] = 0;
    } else if (nowType == 4) {
        floatVar[varName] = 0;
    } else {
        charVar[varName] = '\0';
    }
}

void getvar(const string &varName) {
    if (nowType == 0) {
        intVar[varName] = intData.top();
        intData.pop();
    } else if (nowType == 1) {
        stringVar[varName] = stringData.top();
        stringData.pop();
    } else if (nowType == 2) {
        boolVar[varName] = boolData.top();
        boolData.pop();
    } else if (nowType == 3) {
        doubleVar[varName] = doubleData.top();
        doubleData.pop();
    } else if (nowType == 4) {
        floatVar[varName] = floatData.top();
        floatData.pop();
    } else {
        charVar[varName] = charData.top();
        charData.pop();
    }
}

void pushVar(const string &varName) {
    if (nowType == 0) {
        intData.push(intVar[varName]);
    } else if (nowType == 1) {
        stringData.push(stringVar[varName]);
    } else if (nowType == 2) {
        boolData.push(boolVar[varName]);
    } else if (nowType == 3) {
        doubleData.push(doubleVar[varName]);
    } else if (nowType == 4) {
        floatData.push(floatVar[varName]);
    } else {
        charData.push(charVar[varName]);
    }
}

void ifEqual() {
    if (nowType == 0) {
        HyperInt a = intData.top();
        intData.pop();
        HyperInt b = intData.top();
        intData.pop();
        boolData.push(a == b);
    } else if (nowType == 1) {
        string a = stringData.top();
        stringData.pop();
        string b = stringData.top();
        stringData.pop();
        boolData.push(a == b);
    } else if (nowType == 2) {
        bool a = boolData.top();
        boolData.pop();
        bool b = boolData.top();
        boolData.pop();
        boolData.push(a == b);
    } else if (nowType == 3) {
        double a = doubleData.top();
        doubleData.pop();
        double b = doubleData.top();
        doubleData.pop();
        boolData.push(a == b);
    } else if (nowType == 4) {
        float a = floatData.top();
        floatData.pop();
        float b = floatData.top();
        floatData.pop();
        boolData.push(a == b);
    } else {
        unsigned char a = charData.top();
        charData.pop();
        unsigned char b = charData.top();
        charData.pop();
        boolData.push(a == b);
    }
}

void ifBig() {
    if (nowType == 0) {
        HyperInt a = intData.top();
        intData.pop();
        HyperInt b = intData.top();
        intData.pop();
        boolData.push(a > b);
    } else if (nowType == 1) {
        string a = stringData.top();
        stringData.pop();
        string b = stringData.top();
        stringData.pop();
        boolData.push(a > b);
    } else if (nowType == 2) {
        bool a = boolData.top();
        boolData.pop();
        bool b = boolData.top();
        boolData.pop();
        boolData.push(a > b);
    } else if (nowType == 3) {
        double a = doubleData.top();
        doubleData.pop();
        double b = doubleData.top();
        doubleData.pop();
        boolData.push(a > b);
    } else if (nowType == 4) {
        float a = floatData.top();
        floatData.pop();
        float b = floatData.top();
        floatData.pop();
        boolData.push(a > b);
    } else {
        unsigned char a = charData.top();
        charData.pop();
        unsigned char b = charData.top();
        charData.pop();
        boolData.push(a > b);
    }
}

void ifSmall() {
    if (nowType == 0) {
        HyperInt a = intData.top();
        intData.pop();
        HyperInt b = intData.top();
        intData.pop();
        boolData.push(a < b);
    } else if (nowType == 1) {
        string a = stringData.top();
        stringData.pop();
        string b = stringData.top();
        stringData.pop();
        boolData.push(a < b);
    } else if (nowType == 2) {
        bool a = boolData.top();
        boolData.pop();
        bool b = boolData.top();
        boolData.pop();
        boolData.push(a < b);
    } else if (nowType == 3) {
        double a = doubleData.top();
        doubleData.pop();
        double b = doubleData.top();
        doubleData.pop();
        boolData.push(a < b);
    } else if (nowType == 4) {
        float a = floatData.top();
        floatData.pop();
        float b = floatData.top();
        floatData.pop();
        boolData.push(a < b);
    } else {
        unsigned char a = charData.top();
        charData.pop();
        unsigned char b = charData.top();
        charData.pop();
        boolData.push(a < b);
    }
}

char casmIf(const string &code) {
    if (code == "RET") {
        return 'b';
    }
    if(boolData.top()){
        boolData.pop();
        runCode(code);
    }
    return '\0';
}

void casmRand(const string& num1,const string& num2){
    long long int data1 = 0;
    for (char i: num1) {
        data1 = data1 * 10;
        data1 = data1 + i - '0';
    }
    long long int data2 = 0;
    for (char i: num2) {
        data2 = data2 * 10;
        data2 = data2 + i - '0';
    }
    intData.push((HyperInt)rand() % data2 + data1);
}

void clear() {
    if (nowType == 0) {
        while(!intData.empty()) {
            intData.pop();
        }
    } else if (nowType == 1) {
        while(!stringData.empty()) {
            stringData.pop();
        }
    } else if (nowType == 2) {
        while(!boolData.empty()) {
            boolData.pop();
        }
    } else if (nowType == 3) {
        while(!doubleData.empty()) {
            doubleData.pop();
        }
    } else if (nowType == 4) {
        while(!floatData.empty()) {
            floatData.pop();
        }
    } else {
        while(!charData.empty()) {
            charData.pop();
        }
    }
}
void casmNot(){
    bool x=!boolData.top();
    boolData.pop();
    boolData.push(x);
}
int main(int argc, char* argv[]) {
    srand(time(nullptr));
    if(argc == 1){
        cout << "Please input the file name" << endl;
        return 0;
    }
    const char* name = argv[1];
    freopen(name, "r", stdin);
    knifeCode();
    fclose(stdin);
    freopen("CON", "r", stdin);
    cin.clear();
    setType("INT");
    runCode("MAIN");
    return 0;
}
char upper(const char& i){
    char x = i;
    if('a'<=i&&i<='z') x-=32;
    return x;
}
Lines analysisLine(const string &line) {
    /* EACH LINE IN CASM(EXCEPT COMMENT) HAS ONLY A OPERATOR AND MANY
         * PARAMETER. THE ONLY THINGS THAT IT NEEDS TO DO IS RECORD THEM
         * AND RUN THEM.
         */
    Lines res;
    bool flag = false;
    for (char i: line) {
        if (i == ' ') {
            if (res.len == -1 && (!flag)) continue;
            res.len++;
            if (res.len != 0)
                res.strData += i;
            continue;
        } else {
            if (res.len == -1) flag = true;
        }
        if (i == ';') break;
        if (res.len == -1) res.op += upper(i);
        else res.params[res.len] += i, res.strData += i;
    }
    res.len++; /* NO SPACE FOLLOWS LAST ARG */
    return res;
}

void knifeCode() {
    string code;
    string name;
    while (getline(cin, code, '\n')) {
        Lines l = analysisLine(code);
        if (l.op == "FUNC") {
            name = l.params[0];
            list<string> lines;
            codes.insert(pair<string, list<string>>(name, lines));
        } else {
            codes[name].push_back(code);
        }
    }
}

void runCode(const string &name) {
    for (auto &nowLine: codes[name]) {
        Lines line = analysisLine(nowLine);
        if (line.op == "TYPE") {
            setType(line.params[0]);
        } else if (line.op == "PUSH") {
            push(line);
        } else if (line.op == "EXIT") {
            exit(0);
        } else if (line.op == "OUT") {
            out();
        } else if (line.op == "ENDL") {
            endLine();
        } else if (line.op == "PUSHCOMMENT") {
            pushComment();
        } else if (line.op == "POP") {
            pop();
        } else if (line.op == "ADD") {
            add();
        } else if (line.op == "SUB") {
            sub();
        } else if (line.op == "MUL") {
            mul();
        } else if (line.op == "DIV") {
            div();
        } else if (line.op == "IN") {
            casmIn();
        } else if (line.op == "MOD") {
            mod();
        } else if (line.op == "VAR") {
            var(line.params[0]);
        } else if (line.op == "GETVAR") {
            getvar(line.params[0]);
        } else if (line.op == "PUSHVAR") {
            pushVar(line.params[0]);
        } else if (line.op == "IFE") {
            ifEqual();
        } else if (line.op == "IFB") {
            ifBig();
        } else if (line.op == "IFS") {
            ifSmall();
        } else if (line.op == "GOTO") {
            runCode(line.params[0]);
        } else if(line.op == "IF"){
            if(casmIf(line.params[0])=='b')break;
        } else if (line.op =="RAND"){
            casmRand(line.params[0], line.params[1]);
        } else if (line.op == "CLEAR"){
            clear();
        } else if (line.op == "NOT"){
            casmNot();
        }
    }
}
其中的“hint.hpp”为GitHub上开源的高精度库，非常好用，链接：github.com/With-Sky/HyperInt 作者：WS_TSKY https://www.bilibili.com/read/cv18911017/

本文目的仅为发布源代码，如果真有人向学习CASM，请在下方留言。

最后说一句：不喜勿喷！

cgy091107
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
casm：CASM项目
02-05
casm：CASM项目
开发自己的编程语言
a499068735的专栏
02-03 4880
编程是一门艺术，而编程语言则是这门艺术的缔造者。计算机系的很多学生都对编程语言涉及到的编译原理表示畏惧，其实编译原理本身并不复杂，不过由于目前市面上有关编译原理的书籍大部分都是由国外的原著翻译过来的，翻译过来的文字很多时候没办法完美的表达出原文的意思，所以有时候让人感觉像天书，例如国外有名的 龙书(Dragon book)，龙书是Alfred V. Aho等人于1986年出版的，虽然时隔了几十年，
编写一个自己的编程语言 - 引
moyanjdc的博客
09-03 293
编写自己的编程语言可以帮助你更深入地了解计算机科学和编译原理等方面的知识，也可以让你实现自己的愿望，让自己的想法得以实现。在实现编程语言的过程中，可能会遇到各种困难和挑战，例如语言设计的合理性、实现的效率和正确性等。但是这个过程也会让你深入了解计算机科学和编程语言设计的知识，提高自己的编程技能和思维能力。总而言之，编写自己的编程语言是一项充满挑战性和创造性的任务，需要大量的学习和实践。编写一个编程语言涉及到多个领域的知识和技能，包括计算机科学、编译原理、语言设计和实现等。上一篇：这就是第一篇。
自己去创建一个编程语言吧（4）
薄荷醇
08-05 3857
从本节开始，要写代码了，我会把我开发menthol的所有过程，详细的写出来 1.开发语言的选择 开发一个编程语言，作为开发这个语言所使用的开发语言，可选择性比较多，比如java、c#,还有运行在服务器上的JS 都没有问题。但作为一个编程语言，需要考虑的是程序的稳定、效率、和使用的便捷性、运行环境等，使用JAVA,C#等语言固然可以降低开发的难度，但效率和运行环境就有了一些限制，这些语言本身是运行在一个虚拟的环境中，也就是说，当你开发完一个新的编程语言后，要运行它，还需要把开发他的环境也运行才可以，这样，你
自己动手写脚本语言
flysnowxg的专栏
09-02 6074
这是我用c++写的一个简单的脚本语言，非常简短，不到3000行代码 代码svn地址：http://sil-language.googlecode.com/svn/trunk 新浪爱问：http://ishare.iask.sina.com.cn/f/61318451.html sil语言（simple interpretative lanuage）是一个简单的脚本语言，只是一个玩具
用C++做自己的编程语言（一）
weixin_70056170的博客
01-24 1284
祝大家新年快乐！从今天开始，我将教大家如何自己开发一门编程语言！一、目的 一个编程语言，应该运行速度快，功能强大，拥有自己的风格、特点。我就以自己做的编程语言为例，教大家开发自己的编程语言。二、名称我把我做的编程语言叫做“C+”，因为有C和C++，应该再加一个C+。但是我相信你们会有更好的想法！三、大致框架99%的人都会这样做：把一行代码拆成一个一个的token，然后用NBF来执行它。我给大家提供一个全新的思路：任何一行代码都可以看成一个中缀表达式，而中缀表达式可以用栈来实现。所以，我们会用栈来执行
用C++从0开始开发自己的编程语言
weixin_41659551的博客
06-15 6731
目录导语取名记使用语言项目架构项目架构图项目文件结构解释器流程着手实现接口文件编写语言内存实现 导语 这是我第一次准备发文章，准备徐徐道来，慢慢推进与讲解编程语言解释器的算法和代码。 都说程序员的最大理想就是开发出自己的编程语言来，现在，我也开始完成我最大的理想——开发我属于我自己的编程语言。 阅读了许多关于自制编程语言的数据，可略感失望，感觉很多都是使用yacc/lex这些他人写好的工具生成代码...
使用c++ 作为脚本语言制作协议转换中心
qianbo042311的博客
07-09 884
首先底层可以使用angelscript，这一点无需质疑，不用再造轮子，因为作者做得比较好，测试的例子也非常好，同时，使用angelscript的游戏也是非常多的，下面简单先使用注册main 和测试函数来进行一个协议转换中心的制作，从而使得非c++ 的人员甚至前端也可以使用脚本c++来制作复杂的媒体工具和协议工具。 首先脚本如下所示： 和c，c++ 一样，main函数是入口，前面是一些测试函数，其中 1 tostring(int num) 2 rtsp(string url)此2个函数都是自定义函数，
自己去创建一个编程语言吧（1）
热门推荐
薄荷醇
05-08 1万+
你一定有过这种困惑，一直想要找到一个完全适合自己编码风格，开发习惯的语言。却发现每一个语言各有优略，没有哪个能完全适合你的… 或者你看到现在层出不穷的各种编程语言，难道就没有想装个逼，自己搞一个玩玩的冲动？ 爱装逼的人都拥有同样的气质，所以，我就尝试自己创建了一个编程语言------------Menthol 所以，你也不用想了，自己开发一个吧。 下面我将以我创建Menthol语言过程为例子，...
如何做一个编程语言
m0_55699924的博客
04-29 2053
创建编程语言需要深入的计算机科学知识和编程经验。创建一个编程语言是一个复杂的过程，涉及多个步骤。
casm-utilities-factor_group：该实用程序将输入结构的因子组打印为json
02-17
casm-utilities-factor_group：该实用程序将输入结构的因子组打印为json
code_casm.rar_DSP编程_Visual_C++_
08-11
一个完整的DSp程序，可以进行仿真，是C6416的
casm-开源
05-15
C转换成汇编语言转换器，生成asm文件，针对不同芯片制造商（英特尔，AMD和Transmeta）的特定优化，以C / C ++编写，具有OOP设计，旨在实现多平台
CASMcode_docs:CASM的文档
05-04
CASM在线文档该存储库包含。在本地运行站点获得基本帮助更新jekyll： 捆绑更新github-pages 要运行（从仓库根目录）： 出口JEKYLL_GITHUB_TOKEN=<your> 捆绑执行jekyll服务-增量在浏览器中打开：
数据结构与算法学习笔记七--二叉树(C++)
最新发布
我叫柱子哥
04-23 608
在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。根节点（Root）：树中的唯一顶层节点，没有父节点。
【C】 初识C语言
努力学习C/C++
04-21 764
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
C++ WebServer的细节理解
我的博客
04-22 595
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
C++——初识模板
qq_74245477的博客
04-22 885
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
【C++风云录】精益求精：探索C++开发中的性能优化艺术
记录我的学习历程
04-21 1067
本文将介绍几个在C++开发中常用的性能分析工具和性能优化工具集，包括PerfTools、gperftools、Valgrind、Intel VTune、PAPI以及Boost.Profile。通过深入了解这些工具的功能和用途，读者可以更好地理解如何利用它们来提高代码的执行效率和资源利用率。
0x00007FFE52FFF551 (ucrtbased.dll)处(位于 CASM_PPP.exe 中)引发的异常: 0xC0000005: 读取位置 0x0000000000000000 时发生访问冲突。 出现了
09-05
这个异常通常是访问空指针引发的。0xC0000005 是一种常见的异常代码，表示访问违规，而读取位置 0x0000000000000000 表示尝试访问空指针地址。在你提供的信息中，异常发生在 ucrtbased.dll 模块中的 CASM_PPP.exe 中。 要解决这个问题，你可以尝试以下几个步骤： 1. 确认你的代码中是否存在可能导致空指针访问的错误。检查你是否正确地分配了内存，并且没有尝试在未初始化或已释放的指针上进行操作。 2. 使用调试器来跟踪异常的发生位置。通过检查堆栈跟踪，你可以确定是哪个函数或代码段引发了异常，并进一步分析和修复问题。 3. 确保你的 DLL 文件（比如 ucrtbased.dll）是正确的版本，并与你的应用程序兼容。确保你使用的是最新的 DLL 版本，并且没有损坏或错误的 DLL 文件。 4. 在编译和链接时，确保正确设置了相关选项和依赖项。检查你的项目配置和链接器设置，确保正确引用了所需的库文件，并设置正确的搜索路径。 如果以上方法都无法解决问题，你可能需要进一步调查并考虑与相关技术支持进行联系，以获取更具体的帮助和指导。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值