C++ c++；初始化大小为“的字符数组”；静态*int"；模板内函数

是否可以使用包含在static*int中的大小初始化模板函数内的char数组

.标题

static int * array_size;

template <class T>
void f(T value)
{
    char buffer[*array_size];
}

静态int*数组大小；
模板
空隙f（T值）
{
字符缓冲区[*数组大小]；
}

---

或者是否有方法初始化“数组大小”，以便模板使用默认值？

静态int*数组大小

将无法工作，因为指针内的数据是可修改的，因此无法在编译时确定

如果您使用的是C++11，我建议您

constexpr int array_size = 42;

如果您不能使用C++11，我将使用：

static const int array_size = 42;

在这两种情况下，您创建的缓冲区如下所示：

char buffer[array_size];

所以没有星号

如果在编译时无法找到缓冲区的大小（因此大小取决于运行时的决定），则需要使用动态数组，最好封装到

std:：vector

：

std::vector<char> bufferVec(myDynamicSize); // Use any integer you want to
char *buffer = &bufferVec[0]; // Use this buffer as a standard array 
                              // with size myDynamicSize OR use the std::vector
                              // directly (much cleaner)

std:：vector bufferVec（myDynamicSize）；//使用您想要的任何整数
char*buffer=&bufferVec[0]；//将此缓冲区用作标准数组
//使用size mydynamicze或使用std:：vector
//直接（更干净）

static int*array\u size无法工作，因为指针内的数据是可修改的，因此无法在编译时确定

如果您使用的是C++11，我建议您

constexpr int array_size = 42;

如果您不能使用C++11，我将使用：

static const int array_size = 42;

在这两种情况下，您创建的缓冲区如下所示：

char buffer[array_size];

所以没有星号

如果在编译时无法找到缓冲区的大小（因此大小取决于运行时的决定），则需要使用动态数组，最好封装到

std:：vector

：

std::vector<char> bufferVec(myDynamicSize); // Use any integer you want to
char *buffer = &bufferVec[0]; // Use this buffer as a standard array 
                              // with size myDynamicSize OR use the std::vector
                              // directly (much cleaner)

std:：vector bufferVec（myDynamicSize）；//使用您想要的任何整数
char*buffer=&bufferVec[0]；//将此缓冲区用作标准数组
//使用size mydynamicze或使用std:：vector
//直接（更干净）

static int*array\u size无法工作，因为指针内的数据是可修改的，因此无法在编译时确定

如果您使用的是C++11，我建议您

constexpr int array_size = 42;

如果您不能使用C++11，我将使用：

static const int array_size = 42;

在这两种情况下，您创建的缓冲区如下所示：

char buffer[array_size];

所以没有星号

如果在编译时无法找到缓冲区的大小（因此大小取决于运行时的决定），则需要使用动态数组，最好封装到

std:：vector

：

std::vector<char> bufferVec(myDynamicSize); // Use any integer you want to
char *buffer = &bufferVec[0]; // Use this buffer as a standard array 
                              // with size myDynamicSize OR use the std::vector
                              // directly (much cleaner)

std:：vector bufferVec（myDynamicSize）；//使用您想要的任何整数
char*buffer=&bufferVec[0]；//将此缓冲区用作标准数组
//使用size mydynamicze或使用std:：vector
//直接（更干净）

static int*array\u size无法工作，因为指针内的数据是可修改的，因此无法在编译时确定

如果您使用的是C++11，我建议您

constexpr int array_size = 42;

如果您不能使用C++11，我将使用：

static const int array_size = 42;

在这两种情况下，您创建的缓冲区如下所示：

char buffer[array_size];

所以没有星号

如果在编译时无法找到缓冲区的大小（因此大小取决于运行时的决定），则需要使用动态数组，最好封装到

std:：vector

：

std::vector<char> bufferVec(myDynamicSize); // Use any integer you want to
char *buffer = &bufferVec[0]; // Use this buffer as a standard array 
                              // with size myDynamicSize OR use the std::vector
                              // directly (much cleaner)

std:：vector bufferVec（myDynamicSize）；//使用您想要的任何整数
char*buffer=&bufferVec[0]；//将此缓冲区用作标准数组
//使用size mydynamicze或使用std:：vector
//直接（更干净）

数组大小的限定符必须是常量，否则将以期望的常量表达式结束。静态关键字是不相关的

const int array_size = 42;
char buffer[array_size];

即使指针指向常量，指针取消引用也不会起作用

const int a = 42;
int const * const array_size = &a;
char buffer[array_size]; // error C2057: expected constant expression

您还可以通过模板参数粘贴数组大小：

template <class T, int array_size>
void f(T value)
{
  char buffer[array_size];
}

f<int, 42>(100);

模板
空隙f（T值）
{
字符缓冲区[数组大小]；
}
f（100）；

数组大小的限定符必须是常量，否则将以期望的常量表达式结束。静态关键字是不相关的

const int array_size = 42;
char buffer[array_size];

即使指针指向常量，指针取消引用也不会起作用

const int a = 42;
int const * const array_size = &a;
char buffer[array_size]; // error C2057: expected constant expression

您还可以通过模板参数粘贴数组大小：

template <class T, int array_size>
void f(T value)
{
  char buffer[array_size];
}

f<int, 42>(100);

模板
空隙f（T值）
{
字符缓冲区[数组大小]；
}
f（100）；

数组大小的限定符必须是常量，否则将以期望的常量表达式结束。静态关键字是不相关的

const int array_size = 42;
char buffer[array_size];

即使指针指向常量，指针取消引用也不会起作用

const int a = 42;
int const * const array_size = &a;
char buffer[array_size]; // error C2057: expected constant expression

您还可以通过模板参数粘贴数组大小：

template <class T, int array_size>
void f(T value)
{
  char buffer[array_size];
}

f<int, 42>(100);

模板
空隙f（T值）
{
字符缓冲区[数组大小]；
}
f（100）；

数组大小的限定符必须是常量，否则将以期望的常量表达式结束。静态关键字是不相关的

const int array_size = 42;
char buffer[array_size];

即使指针指向常量，指针取消引用也不会起作用

const int a = 42;
int const * const array_size = &a;
char buffer[array_size]; // error C2057: expected constant expression

您还可以通过模板参数粘贴数组大小：

template <class T, int array_size>
void f(T value)
{
  char buffer[array_size];
}

f<int, 42>(100);

模板
空隙f（T值）
{
字符缓冲区[数组大小]；
}
f（100）；

为什么要在此处使用指针？

[]

中的表达式必须是常量表达式，因此不能使用可修改类型<代码>静态constexpr int const*数组大小=&my\u大小（其中

my_size

为，例如

constexpr int

）是可能的，但不确定您为什么要使用它。我正在尝试使用一个可以更改其大小的缓冲区。在编译时必须知道缓冲区大小。可以使用

std:：vector

而不是数组。为什么要在此处使用指针？

[]

中的表达式必须是常量表达式，因此不能使用可修改类型<代码>静态constexpr int const*数组大小=&my\u大小（其中

my\u si