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

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是非常量值而且我不想做LogicalExpression<varLenght> obj 。 希望我的英语不会那么差，因为不了解我。

Answer 1

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

模板在编译时进行评估。 因此，<>之间的值不能包含非常量 。 根本不可能，因为没有在运行时评估模板。 这实际上是一种优势，而不是劣势（请参阅TMP ）。 为了进行比较，它们更像是预处理器定义，然后说一个函数调用，但实际上它们与宏并不相同

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

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

您要么希望“数字”成为一个动态数组 ，以使其变成类似以下内容：

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 。

或 “ LogicalExpression”应该是模板类（您已经说过不需要）

 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

“某处”，如果它具有语法味道，则可以使用类似以下内容的方法：

   typedef LogicalExpresion8Bit LogicalExpression<8>

如果要进行动态评估，则必须使用动态内存或某种有点疯狂的东西（例如多态和接口的组合），这很可能会导致堆栈上有更多的内存，那么您实际上想要/需要，更不用说很多代码了...（即，每个变量都存储在数组中并通过索引选择）。