一个简单的虚拟机

81 阅读 0 评论 54 点赞

我是靠谱客的博主香蕉长颈鹿，最近开发中收集的这篇文章主要介绍一个简单的虚拟机，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

一个简单的虚拟机，虚拟机有100个字的内存，几个寄存器——指令计数器、指令寄存器、操作码寄存器、内存地址寄存器、累加寄存器。可以——输入01、输出02、加载数据到寄存器03、存放数据到内存04、简单的加05减06乘07除08运算、转移09、小于零转移10、等于零转移11、终止12。程序输入完，输入0000结束。

打印两个数中的较大数

0120 //输入一个数到内存20

0121 //输入一个数到内存21

0320 //加载内存20的数据到累加器

0621 //累加器数据减去内存21 的数据

1007 //如果小于零转移到内存07

0220 //输出内存20的数据

1200 //终止

0221 //输出内存21的数据

1200 //终止

0000 //输入结束

运行

Virtual machine is booting...

Complete booting.

Please input your program.

00 0120

01 0121

02 0320

03 0621

04 1007

05 0220

06 1200

07 0221

08 1200

09 0000

Good job.

Virtual machine is loading the program...

Complete loading.

Virtual machine is printing the program...

00 0120

01 0121

02 0320

03 0621

04 1007

05 0220

06 1200

07 0221

08 1200

Complete printing.

Virtual machine is running the program...

opcode address

01 20

100

opcode address

01 21

200

opcode address

03 20

opcode address

06 21

opcode address

10 07

opcode address

02 21

200

Complete running.

Virtual machine is shutting...

Complete shutting.

//leaf_core_test.cpp文件

// Copyright (c) LeafCore
#include < iostream >
#include " leaf_core_virtual_machine.hpp "

using namespace std;

int main( int argc, char * argv[])
{
    CVirtualMachine virtual_machine; // 创建虚拟机对象
     int program[ 100 ]; // 存放程序
     int buffer;

     // 启动虚拟机
    virtual_machine.boot();

     // 输入程序
    cout << " Please enter your program " << endl;
    cout << " 00t " ;
    cin >> buffer;
     for ( int index = 0 ; (program[index] = buffer) != 0 ; index ++ ) {
        cout << (index + 1 ) / 10 << (index + 1 ) % 10 << " t " ;
        cin >> buffer;
    }
    cout << " Good job.n " << endl;

     // 加载程序到虚拟机内存
    virtual_machine.load_program(program);
     // 打印程序
    virtual_machine.print_program();
     // 运行程序
    virtual_machine.run_program();

     // 关闭虚拟机
    virtual_machine.shut();

     char ch;
    cout << " Window closing " << endl;
    cin >> ch;
     return 0 ;
}

//leaf_core_virtual_machine.hpp文件

// Copyright (c) LeafCore
#ifndef __leaf_core_virtual_machine_hpp__
#define __leaf_core_virtual_machine_hpp__

class CVirtualMachine {
private :
     int m_memory[ 100 ]; // 内存
     int m_instruction_counter; // 指令计数器
     int m_instruction_register; // 指令寄存器
     int m_opcode; // 操作码
     int m_address; // 内存地址
     int m_accumulator; // 寄存器
public :
// Virtual Machine操作码
     static const int const_input = 1 ; // 存放用户输入数据到内存
     static const int const_print = 2 ; // 输出内存数据到屏幕
     static const int const_load = 3 ; // 加载内存数据到寄存器
     static const int const_store = 4 ; // 存放寄存器数据到内存
     static const int const_plus = 5 ; // 寄存器数据加上内存数据
     static const int const_minus = 6 ; // 寄存器数据减去内存数据
     static const int const_multiply = 7 ; // 寄存器数据乘以内存数据
     static const int const_divide = 8 ; // 寄存器数据除以内存数据
     static const int const_branch = 9 ; // 转移
     static const int const_branch_below = 10 ; // 寄存器数据小于零转移
     static const int const_branch_zero = 11 ; // 寄存器数据等于零转移
     static const int const_halt = 12 ; // 终止
public :
    CVirtualMachine();
     ~ CVirtualMachine();

     void boot(); // 启动虚拟机
     void shut(); // 关闭虚拟机
     void load_program( int * program); // 加载程序到虚拟机内存
     void print_program(); // 打印程序
     void run_program(); // 运行程序
};

#endif

//leaf_core_virtual_machine.cpp文件

// Copyright (c) LeafCore
#include < iostream >
#include " leaf_core_virtual_machine.hpp "

using namespace std;

// 初始化虚拟机
CVirtualMachine::CVirtualMachine()
{
    m_instruction_counter = 0 ;
    m_instruction_register = 0 ;
    m_opcode = 0 ;
    m_address = 0 ;
}

CVirtualMachine:: ~ CVirtualMachine()
{
}

// 启动虚拟机
void CVirtualMachine::boot()
{
    cout << " Virtual machine is booting

" << endl;
cout << " Complete booting.n " << endl;
}

// 关闭虚拟机
void CVirtualMachine::shut()
{
cout << " Virtual machine is shutting

" << endl;
    cout << " Complete shutting.n " << endl;
}

// 加载程序到虚拟机内存
void CVirtualMachine::load_program( int * program)
{
     int index;
    cout << " Virtual machine is loading the program

" << endl;
     for (index = 0 ; index < 100 && program[index] != 0 ; index ++ ) {
        m_memory[index] = program[index];
    }
    m_memory[index] = program[index];
    cout << " Complete loading.n " << endl;
}

// 打印程序
void CVirtualMachine::print_program()
{
     int index;
    cout << " Virtual machine is printing the program

" << endl;
     for (index = 0 ; index < 100 && m_memory[index] != 0 ; index ++ ) {
        cout << index / 10 << index % 10 << " t " ;
        cout << m_memory[index] / 1000 << m_memory[index] % 1000 / 100
             << m_memory[index] % 100 / 10 << m_memory[index] % 10 << endl;
    }
    cout << " Complete printing.n " << endl;
}

// 运行程序
void CVirtualMachine::run_program()
{
     int index;
    cout << " Virtual machine is running the program

" << endl;

     // 取出指令
    m_instruction_counter = 0 ;
    m_instruction_register = m_memory[m_instruction_counter ++ ];
     // 指令解码
    m_opcode = m_instruction_register / 100 ;
    m_address = m_instruction_register % 100 ;
     for (index = 0 ; index < 100 && m_opcode != const_halt; index ++ ) {
        cout << " opcodetaddress " << endl;
        cout << m_opcode / 10 << m_opcode % 10 << " t " << m_address / 10 << m_address % 10 << endl;

         // 执行指令
         switch (m_opcode) {
         case const_input:
             int buffer;
            cin >> buffer;
            m_memory[m_address] = buffer;
             break ;
         case const_print:
            cout << m_memory[m_address] << endl;
             break ;
         case const_load:
            m_accumulator = m_memory[m_address];
             break ;
         case const_store:
            m_memory[m_address] = m_accumulator;
             break ;
         case const_plus:
            m_accumulator += m_memory[m_address];
             break ;
         case const_minus:
            m_accumulator -= m_memory[m_address];
             break ;
         case const_multiply:
            m_accumulator *= m_memory[m_address];
             break ;
         case const_divide:
            m_accumulator /= m_memory[m_address];
             break ;
         case const_branch:
            m_instruction_counter = m_address;
             break ;
         case const_branch_below:
             if (m_accumulator < 0 ) {
                m_instruction_counter = m_address;
            }
             break ;
         case const_branch_zero:
             if (m_accumulator == 0 ) {
                m_instruction_counter = m_address;
            }
             break ;
         default :
             break ;
        }
        cout << endl;

         // 取出指令
        m_instruction_register = m_memory[m_instruction_counter ++ ];
         // 指令解码
        m_opcode = m_instruction_register / 100 ;
        m_address = m_instruction_register % 100 ;
    }
    cout << " Complete running.n " << endl;
}