Question

我做了两个类，第一个是模板类Bit<size>，它将十进制数转换为二进制数。第二个是LogicalExpression类。

比特级：

template<int size>
class Bit
{
public:
    Bit(int);
    void ConvertToBinary(int);
    bool number[size];
    int bit;
};

template <int size> Bit<size>::Bit(int decimalNumber)
{
    this->bit = 0;
    ConvertToBinary(decimalNumber);
}

template <int size> void Bit<size>::ConvertToBinary(int decimalNumber)
{
    number[size - ++this->bit] = decimalNumber % 2;
    if (size != this->bit) {
        ConvertToBinary(decimalNumber / 2);
    }
}

LogicalExpression类：

#include "Bit.h"
class LogicalExpression
{
private:
    char* expression;
    char* variables;
    int expLenght;
    int varLenght;

public:
    LogicalExpression(char*);
    ~LogicalExpression();
    bool ExpressionToBoolean(char*, Bit<????>); //here is the problem

我想将 LogicalExpression 类用作普通的非模板类，因此我不知道如何为 Bit<???> 声明const参数，它应该是 Bit<varLenght> ，但 varLenght 是非常量值，我不想 {{ 1}} 。希望我的英语不那么糟糕，因为不了解我。

Answer 1

这里的问题可能是对模板如何工作的误解。

模板在编译时进行评估。因此，中间的值＆lt; ＆GT; 不能包含非const 。它根本不可能，因为模板在运行时未评估。这实际上是一种力量，而不是弱点（见TMP）。为了进行比较，它们更像是预处理器定义，然后说一个函数调用，但它们实际上是not the same thing as macros

在这种情况下，您需要重新考虑您的设计。在这一部分：

 template<int size>
class Bit
{
public:
    Bit(int);
    void ConvertToBinary(int);
    bool number[size];
    int bit;
};

你要么＆＃34;数字＆＃34;成为dynamic array，以便它变得像：

class Bit
{
public:
    Bit(int length){ number = new bool[length]; } ;
    ~Bit(){delete number;}
    void ConvertToBinary(int);
    bool* number;
    int bit;
};

它不需要是一个模板，可以像：

一样使用

bool ExpressionToBoolean(char*)
{
    Bit foo(varLength); 
}

为简单起见，您可以使用std::vector。

OR ＆＃34; LogicalExpression＆＃34;应该是一个模板类（你说过你不想要）

 template<int varLenght>
class LogicalExpression
{
private:
    char* expression;
    char* variables;
    int expLenght;

public:
    LogicalExpression(char*);
    ~LogicalExpression();
    bool ExpressionToBoolean(char*, Bit<varLenght>); //here is the problem

但实际上这归结为你希望分配内存的问题，你想要它在堆还是堆栈上？

堆：动态数组（可在运行时评估）
stack：模板（无法在运行时评估）

如果你不在乎，我可能会坚持使用动态阵列方法，因为你可能很容易使模板问题复杂化......但是这个问题可能适合TMP，根据你的要求。如果你想要它在堆栈上，那么你将不得不使用某种形式的

LogicalExpression< "const" > obj

＆＃34;某处＆＃34;，如果它具有语法上的味道，你可以使用类似的东西：

   typedef LogicalExpresion8Bit LogicalExpression<8>

如果你想要动态评估，那么你必须要么使用动态内存，要么像某种多变形和接口的组合一样疯狂，这很可能会导致堆栈上更多内存然后你真正想要/需要，更不用说了更多代码...（即每个变体存储在一个数组中并通过索引选择）。

如何向对象模板声明非const参数

1 个答案: