有人能解释一下脑残吗？

Question

我想写一个brainfuck口译员，但我错过了一些上下文或其他东西。应该被调用以处理“

std::vector<int> Interpreter::interpret(const std::string &src_,
    const std::vector<int> & input_)

该程序的测试如下所示：

    int main()
{
std::vector<int> res;
// output: 1
res = interpret("+.");
for (auto i : res)
std::cout << i << " ";
2
// output: 2
res = interpret(",.", {2});
for (auto i : res)
std::cout << i << " ";
return 0;
}

http://www.muppetlabs.com/~breadbox/bf/

我真的不明白这是在做什么。我看过其他视频，但这没有意义。有人能解释一下目标吗？

如果函数被赋予一个要转换的数组，30000字节数组的意义是什么？

编辑：我应该写C代码来翻译字符——brainfuck命令的字符，他们应该在30000字节的数组中执行相应的命令，以及一些这意味着什么。

编辑：提供的说明

摘要为Brainfk写一个简单的解释器

Brainfk程序有一个隐式字节指针，称为指针，可以在一个30000字节的数组中自由移动，最初都设置为零。指针本身被初始化为指向该数组的开头。Brainfuck编程语言由八个命令组成，每个命令都表示为一个字符。

•

例如，一个版本的“你好，世界！”Brainfk中的程序是

++++++++++[>+++++++>++++++++++>+++>+<<<<-]
>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.
+++.------.--------.>+.>.

2要求

2.1测试程序
我将使用程序批量测试和分级您的代码。所以请仔细检查您的函数签名。如果运行不正常，可能会影响您的项目等级。入口函数都将有解释的名称。您可以实现您想要的任何其他辅助函数。以下部分详细说明了规范。

2.1.1 C我将使用C 11（g-std=c 11...）来测试您的程序。因此，请随意使用一些最近添加到C中的好东西，例如lambda函数、数组初始化等。为了方便起见，请将您的声明和实现代码在bf. h和bf.cpp中分开。函数签名是std::向量

我的测试程序看起来像

int main()  
{  
std::vector<int> res;  
// output: 1  
res = interpret("+.");  
for (auto i : res)  
    std::cout << i << " ";  

// output: 2  
res = interpret(",.", {2});  
for (auto i : res)  
    std::cout << i << " ";  
return 0;  
}  

编辑：到目前为止我有什么：

BFK。H

#pragma once
#include <vector>
#include <iostream>

using namespace std;


char arr[30000];
char* p = arr;

void incPtr();

void decPtr();

void incByte();

void decByte();

void printByte();

void setByte();

void jumpF();

void jumpB();

std::vector<int> interpret(const std::string &src,
    const std::vector<int> & input = {});

BFK。cpp

#include "BFK.h"

void incPtr() {
    p++;
}

void decPtr() {
    p--;
}

void incByte() {
    (*p)++;
}

void decByte() {
    (*p)--;
}

void printByte() {
    std::cout << *p;
}

void setByte() {
    std::cin >> *p;
}

void jumpF() {
    if (*p == 0) {

    }
}

void jumpB() {

}


std::vector<int> interpret(const std::string &src_,
    const std::vector<int> & input_){
    int i = 0;
    int max = src_.size();
    while (i < max) {
        switch (src_[i]) {
        case '>':
            incPtr();
            break;
        case '<':
            decPtr();
            break;
        case '+':
            incByte();
            break;
        case '-':
            decByte();
            break;
        case '.':
            printByte();
            break;
        case ',':
            setByte();
            break;
        case '[':
            jumpF();
            break;
        case ']':
            jumpB();
            break;
        }
    }

    return input_;
}

你应该能够在不实例化任何东西的情况下调用expression，所以我不知道另一种方法来将其组合起来。我还没有实现跳转功能。




Answer 1

如果函数被赋予一个要转换的数组，30000字节数组的意义是什么？

想象一下，你得到两个数字——2和5——并希望你的Brainfuck程序打印它们的总和。

当你只能操作当前单元格中的值并“选择”哪个单元格是当前单元格时，你该怎么做？当然，你在某个时候需要一些临时记忆。

为了在两个单独的单元格中有两个值，为加法做准备，您可以这样做：

,>,

如果用户输入2和3（十进制，而非ascii），则Brainfuck程序内存或磁带的前两个字节将如下所示：

[2, 3, 0, 0, ...]
//  ^ This is where our tape pointer is now. We incremented it with `>`

够好了，现在添加的内容呢？一个解决方案是使用脑力循环。

让我们添加两个自然整数，而不做任何事情，只是递增和递减值：

int a = 2, b = 3

while (a != 0)
{
    b += 1
    a -= 1
}

基本上，我们递减第一个值，直到它达到零，当它递减时，我们递增第二个值。随着时间的推移，这将表明：

a = 2, b = 3
a = 1, b = 4
a = 0, b = 5
a == 0, break

因此，我们确实得到了2 3=5。这很简单，可以在brainfuck中实现。

,  Get value for first cell (a)
>, Get value for second cell (b)
<  Move back to a
[  Loop until a == 0
    >+ Decrement b
    <- Increment a
    We are still at a at this point, so everything is alright
]  Loop again if a != 0
>. Print the final result (sum of a plus b)

...所有这些都是为了展示你如何使用大脑的磁带存储器来做实际的事情。

我相信很多Brainfuck程序都将磁带作为堆栈来处理。有趣的是，你实际上并不需要知道Brainfuck程序使用的技术，以可用的方式临时存储值。

让我们看看Brainfuck解释器将如何大致处理上述程序，一条指令接一条指令。

*在堆栈中的值之后表示堆栈指针现在指向该值。

我将对其中一些人进行分组，以避免时间过长。

1. ，-磁带[index]=input（），堆栈现在是[2*，0,0，…]

不用说，我不知道这个问题是2015年的！（耶！）至少将来有人会发现这很有用...：^）