Question

好吧，我认为我解决了大部分问题，但它并不像我想的那样传递常数。非常感谢任何帮助，谢谢。

另外，对于！inputFile部分，我不知道如何像我老师建议的那样启动返回（EXIT_FAILURE）..

另外，至于你的建议只使用数组的一部分，那还能让我在函数中使用整个东西吗？

该程序应该采用这样的文件：例如：不是11010001 并且它应该以字符串形式读取命令，以数组形式读取二进制文件，然后对二进制文件执行命令。

这里的代码只是主要功能，只是不想一次性发送一个墙，如果这看起来没问题，那么我很乐意添加其余部分。此外，void Operate（）函数几乎以某种方式调用所有其他函数......我不确定这是什么导致它或什么。打印表只有cout是一个表格，用于放置所有信息。

并且这些标题对我来说很不错，所以假设这些是正确的。

/* ========================================================================== */

/* Prototypes */

int Power (int, int);

int ReadFile (ifstream inputFile);

void Operate (const int, ifstream&, string, int, int, int);

void CommandNot (const int, int, int);

void CommandAnd (const int, int, int, int);

void CommandOr (const int, int, int, int);

int CommandConvert (const int, int, int);

void CommandLshift (const int, int, int, int);

void PrintTable ();

void PrintOperand (const int &, int);

int main ()
{

//Constants

const int BIT_SIZE = 8;


//Variables


string fileName = "binaryData.txt";

    int operandOne [BIT_SIZE];

    int operandTwo [BIT_SIZE];

    int operandResult [BIT_SIZE];

    ifstream inputFile;

    PrintTable ();
    Operate (BIT_SIZE, inputFile, fileName, operandOne[BIT_SIZE], operandTwo[BIT_SIZE], operandResult[BIT_SIZE]);

    return 0;
}

void PrintTable ()
{

    cout << "=================================================" << endl;
    cout << "=      Eight Bit Binary Number Manipulator      =" << endl;
    cout << "=================================================" << endl << endl;

    cout << setw(14) << "COMMAND" << "Operand #1" << "Operand #2" << "Shift" << "Result" << endl;
    cout << "----------------------------------------------------------------------" << endl;

}

void Operate (const int BIT_SIZE, ifstream& inputFile, string fileName, int operandOne[], int operandTwo[], int operandResult[])
{
    //Variables
    int count, shift;
    char myChar;
    string command;

    const int SIZE = BIT_SIZE;  //rename constant

    inputFile.open (fileName);

    if ( !inputFile )       //Check if file opened sucessfully
    {
        cout << "Error: Data file could not be opened" << endl;
    }

    while (inputFile)       //Read file, and apply commands
    {
        inputFile >> command;
        cout << command << endl;
        for ( count = 0;  count < SIZE; count++ )
        {
            inputFile >> myChar;
            operandOne[count] = myChar - '0';
        }

        if (command == "NOT")
        {
            CommandNot (BIT_SIZE, operandOne[BIT_SIZE], operandResult[BIT_SIZE]);
            PrintOperand (BIT_SIZE, operandResult[BIT_SIZE]);
        }
        else if (command == "AND")
        {
            count = 0;
            for ( count = 0;  count < SIZE; count++ )
            {
                inputFile >> myChar;
                operandTwo[count] = myChar - '0';
            }

            CommandAnd (BIT_SIZE, operandOne[BIT_SIZE], operandTwo[BIT_SIZE], operandResult[BIT_SIZE]);
            PrintOperand (BIT_SIZE, operandResult[BIT_SIZE]);
        }
        else if (command == "OR")
        {
            count = 0;
            for ( count = 0;  count < SIZE; count++ )
            {
                inputFile >> myChar;
                operandTwo[count] = myChar - '0';
            }

            CommandOr (BIT_SIZE, operandOne[BIT_SIZE], operandTwo[BIT_SIZE], operandResult[BIT_SIZE]);
            PrintOperand (BIT_SIZE, operandResult[BIT_SIZE]);
        }
        else if (command == "CONVERT")
        {
            CommandConvert (BIT_SIZE, operandOne[BIT_SIZE], operandResult[BIT_SIZE]);
            PrintOperand (BIT_SIZE, operandResult[BIT_SIZE]);
        }
        else if (command == "LSHIFT")
        {
            inputFile >> shift;
            CommandLshift (BIT_SIZE, operandOne[BIT_SIZE], operandResult[BIT_SIZE], shift);
            PrintOperand (BIT_SIZE, operandResult[BIT_SIZE]);
        }

        else
        {
            command = "INVALID";
            PrintOperand (BIT_SIZE, operandOne[BIT_SIZE]);
            cout << "--- ERROR! Invalid Command ---";
        }
    }

    inputFile.clear();
    inputFile.close();

    return ;
}

void CommandNot (const int BIT_SIZE, int operandOne[], int operandResult[])
{

    int count;
    const int SIZE = BIT_SIZE;

    for ( count = 0;  count < SIZE; count++ )
    {
        if (operandOne[count] == 0)
        {
            operandResult[count] = 1;
        }
        else
        {
            operandResult[count] = 0;
        }
    }

}

void CommandAnd (const int BIT_SIZE, int operandOne[], int operandTwo[], int operandResult[])
{

    int count;
    const int SIZE = BIT_SIZE;

    for ( count = 0;  count < SIZE; count++ )
    {
        if ((operandOne[count] == 1) && (operandTwo[count] == 1))
        {
            operandResult[count] = 1;
        }
        else
        {
            operandResult[count] = 0;
        }
    }

}

void CommandOr (const int BIT_SIZE, int operandOne[], int operandTwo[], int operandResult[])
{

    int count;
    const int SIZE = BIT_SIZE;

    for ( count = 0;  count < SIZE; count++ )
    {
        if ((operandOne[count] == 0) && (operandTwo[count] == 0))
        {
            operandResult[count] = 0;
        }
        else
        {
            operandResult[count] = 1;
        }
    }

}

int CommandConvert (const int BIT_SIZE, int operandOne[])
{

    int count;
    const int SIZE = BIT_SIZE;
    int baseTenResult = 0;
    int place;

    for ( count = 0;  count < SIZE; count++ )
    {
        place = SIZE - (count + 1);
        if (operandOne[count] == 1)
        {
            baseTenResult = baseTenResult + Power (2, place);
        }
        else 
        {
            continue;
        }
    }

    return baseTenResult;
}

void CommandLshift (const int BIT_SIZE, int operandOne[], int operandResult[], int shift)
{

    int count;
    const int SIZE = BIT_SIZE;
    int shiftStart = SIZE - shift;

    for ( count = 0;  count < SIZE-shift; count++ )
    {
        operandResult[count] = operandOne[count + shift];
    }

    for ( count = SIZE - shift; count < SIZE; count++ )
    {
        operandResult[count] = 0;
    }

}

int Power (int base, int power)
{
    int count;
    int result = 1;

    for ( count = 0; count < power; count++ )
    {
        result = result * base;
    }

    return result;
}

void PrintOperand (const int BIT_SIZE, int operandResult[])
{

    int count;
    const int SIZE = BIT_SIZE;

    for ( count = 0;  count < SIZE; count++ )
    {
        cout << operandResult[count];
    }

}

Answer 1

您需要从main调用这些函数。你不能通过重新陈述它们来做到这一点：

void PrintTable();
void Operate (const int BIT_SIZE, ifstream& inputFile, string fileName, int operandOne[], int operandTwo[], int operandResult[]);

相反，你需要打电话给他们：

PrintTable();
Operate(BITSIZE,inputFile,fileName,operandOne,operandTwo,operandResult);

但请注意，还有另一个问题：Operate最后需要三个整数参数，但您似乎尝试使用整数数组作为参数。您需要选择每个数组的一个元素，并仅将其作为参数提交。

（编辑）你的问题中有一些变化，我不明白你的数据和函数的最佳整体结构应该是什么，但如果你正在处理整数数组而你想要要将整个数组传递给一个函数，你可以这样做（我把它简化为一个只需要一个整数数组的函数。当然你可以有多个函数参数）：

#include <iostream>

const int SIZE = 3;

/* This is a simpified version of 'operate'. It
   takes one argument, which is an array of integers. */    
void operate(int a[])
{
  /* The only thing I do is to iterate through
     all elements of the array and print them. */
  int i = 0;
  while (i < SIZE) {
    std::cout << a[i] << std::endl;
    ++i;
  }

  /* IMPORTANT: The length of the array is defined by a
     global constant SIZE. Alternatively, you can pass
     along the size of the array as a separate argument
     to the function. */
}

int main()
{
  /* Main program. Here is our array: */
  int my_array[SIZE] = { 1,2,3 };

  /* And here we call our function: */
  operate(my_array);
  return 0;
}

然而，所有这一切都有点复杂，并不像C ++中那样（而不是C）。很可能，你会更好地不使用数组，并用std::vector替换它们。最好检查cppreference以获取如何使用它的示例（也可以单击某些成员函数，例如构造函数和push_back以获取特定的代码示例。）

C ++跳过函数

1 个答案: