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

How do I declare non-const argumets to an object template

本文关键字：对象 声明 参数 非常 常量      更新时间：2023-10-16

我做了两个类，第一个是将十进制数转换为二进制的模板类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);
    }
}

逻辑表达式类：

#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 。希望我的英语没有那么糟糕，因为听不懂我的话。

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

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

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

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

你要么希望"number"是一个动态数组，这样它就会变成这样的东西：

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。

或者"逻辑表达式"应该是一个模板类（你说过你不想要）

 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

但实际上，这归结为您希望将内存分配到何处的问题，您希望将其放在堆上还是堆栈上？

  • 堆：动态数组（可以在运行时计算）
  • 堆栈：模板（在运行时无法评估）

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

LogicalExpression< "const" > obj

"某处"，如果它是一种语法品味，您可以使用类似的东西： 

   typedef LogicalExpresion8Bit LogicalExpression<8>
如果你想要动态

评估，那么你必须使用动态内存或更疯狂的东西，比如多态和接口的组合，这很可能导致堆栈上有更多的内存，然后你实际想要/需要，更不用说更多的代码了......（即每个变体存储在数组中并通过索引选择）。

相关文章：