在C ++的类初始化器中初始化一个常量数组

我在C ++中有以下类：

class a { const int b[2]; // other stuff follows // and here's the constructor a(void); } 

问题是，如何初始化初始化列表中的b，因为我不能在构造函数的主体中初始化它，因为b是const ？

这不起作用：

 a::a(void) : b([2,3]) { // other initialization stuff } 

编辑：在这种情况下，我可以有不同的值为b不同的实例，但值已知是实例的生命周期不变。

Answer 1

像其他人说的那样，ISO C ++不支持这一点。 但是你可以解决它。 只需使用std :: vector。

 int* a = new int[N]; // fill a class C { const std::vector<int> v; public: C():v(a, a+N) {} }; 

Answer 2

用C ++ 11，这个问题的答案现在已经改变了，你实际上可以这样做：

 struct a { const int b[2]; // other bits follow // and here's the constructor a(); }; a::a() : b{2,3} { // other constructor work } int main() { aa; } 

Answer 3

目前的标准是不可能的。 我相信你可以在C ++ 0x中使用初始化器列表来完成这个工作（参见Bjarne Stroustrup的C ++ 0x简介 ，了解关于初始化器列表和其他很好的C ++ 0x特性的更多信息）。

Answer 4

std::vector使用堆。 哎呀，真正的健康检查只是浪费。 std::vector在运行时是dynamic增长的，而不是在编译时应该做的任何旧的语法检查。 如果你不会增长，那么创build一个类来包装一个普通的数组。

 #include <stdio.h> template <class Type, size_t MaxLength> class ConstFixedSizeArrayFiller { private: size_t length; public: ConstFixedSizeArrayFiller() : length(0) { } virtual ~ConstFixedSizeArrayFiller() { } virtual void Fill(Type *array) = 0; protected: void add_element(Type *array, const Type & element) { if(length >= MaxLength) { // todo: throw more appropriate out-of-bounds exception throw 0; } array[length] = element; length++; } }; template <class Type, size_t Length> class ConstFixedSizeArray { private: Type array[Length]; public: explicit ConstFixedSizeArray( ConstFixedSizeArrayFiller<Type, Length> & filler ) { filler.Fill(array); } const Type *Array() const { return array; } size_t ArrayLength() const { return Length; } }; class a { private: class b_filler : public ConstFixedSizeArrayFiller<int, 2> { public: virtual ~b_filler() { } virtual void Fill(int *array) { add_element(array, 87); add_element(array, 96); } }; const ConstFixedSizeArray<int, 2> b; public: a(void) : b(b_filler()) { } void print_items() { size_t i; for(i = 0; i < b.ArrayLength(); i++) { printf("%d\n", b.Array()[i]); } } }; int main() { ax; x.print_items(); return 0; } 

ConstFixedSizeArrayFiller和ConstFixedSizeArray是可重用的。

第一个允许运行时边界检查，同​​时初始化数组（与vector相同），在初始化之后，该数组可以稍后变为const 。

第二个允许将数组分配给另一个对象，这个对象可能在堆上，或者只是在堆栈中，如果这是对象所在的位置。 从堆中分配没有浪费时间。 它还对数组执行编译时const检查。

b_filler是一个很小的私有类，用于提供初始化值。 在编译时使用模板参数来检查数组的大小，所以不会有出界的机会。

我相信有更奇特的方法来修改这个。 这是一个初步的刺。 我想你几乎可以弥补任何编译器的缺点。

Answer 5

ISO标准C ++不会让你这样做。 如果是这样，语法可能是：

 a::a(void) : b({2,3}) { // other initialization stuff } 

或类似的规定。 从你的问题，它实际上听起来像你想要的是一个常数类（又名静态）成员是数组。 C ++可以让你这样做。 像这样：

 #include <iostream> class A { public: A(); static const int a[2]; }; const int A::a[2] = {0, 1}; A::A() { } int main (int argc, char * const argv[]) { std::cout << "A::a => " << A::a[0] << ", " << A::a[1] << "\n"; return 0; } 

输出是：

 A::a => 0, 1 

当然，因为这是一个静态类成员，所以对于类A的每个实例都是一样的。如果这不是你想要的，即你想让A的每个实例在数组a中有不同的元素值，那么你正在试图使数组开始的错误。 你应该这样做：

 #include <iostream> class A { public: A(); int a[2]; }; A::A() { a[0] = 9; // or some calculation a[1] = 10; // or some calculation } int main (int argc, char * const argv[]) { A v; std::cout << "va => " << va[0] << ", " << va[1] << "\n"; return 0; } 

Answer 6

如果我有一个常量数组，它总是以静态方式完成。 如果你可以接受，这个代码应该编译并运行。

 #include <stdio.h> #include <stdlib.h> class a { static const int b[2]; public: a(void) { for(int i = 0; i < 2; i++) { printf("b[%d] = [%d]\n", i, b[i]); } } }; const int a::b[2] = { 4, 2 }; int main(int argc, char **argv) { a foo; return 0; } 

Answer 7

你不能从初始化列表中做到这一点，

看看这个：

http://www.cprogramming.com/tutorial/initialization-lists-c++.html

🙂

Answer 8

不使用std::vector堆的解决scheme是使用boost::array ，尽pipe不能直接在构造函数中初始化数组成员。

 #include <boost/array.hpp> const boost::array<int, 2> aa={ { 2, 3} }; class A { const boost::array<int, 2> b; A():b(aa){}; }; 

Answer 9

有趣的是，在C＃中，你可以将关键字const转换为C ++的静态常量，而不是readonly，它只能在构造函数和初始化中设置，即使是非常量，例如：

 readonly DateTime a = DateTime.Now; 

我同意，如果你有一个const的预先定义的数组，你也可以使它静态。 在这一点上，你可以使用这个有趣的语法：

 //in header file class a{ static const int SIZE; static const char array[][10]; }; //in cpp file: const int a::SIZE = 5; const char array[SIZE][10] = {"hello", "cruel","world","goodbye", "!"}; 

然而，我并没有find一个方法来解决“10”的问题。 原因很明显，它需要知道如何访问数组。 一个可能的select是使用#define，但是我不喜欢这个方法，并且我在头文件尾部加了#undef，并在CPP中编辑注释，以及如果发生改变。

Answer 10

如何通过访问函数来模拟const数组？ 它是非静态的（按照你的要求），它不需要stl或任何其他库：

 class a { int privateB[2]; public: a(int b0,b1) { privateB[0]=b0; privateB[1]=b1; } int b(const int idx) { return privateB[idx]; } } 

因为a :: privateB是私有的，它在::之外是有效的常量，你可以像数组一样访问它，例如

 a aobj(2,3); // initialize "constant array" b[] n = aobj.b(1); // read b[1] (write impossible from here) 

如果你愿意使用一对类，你还可以保护privateB免于成员函数。 这可以通过inheritance一个; 但我想我更喜欢使用const类的John Harrison的comp.lang.c ++文章。