78

我在 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为不同的实例设置不同的值，但已知这些值在实例的生命周期内是恒定的。

4

10 回答 10

82

使用 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() {
 a a;
}
于 2011-10-18T11:11:53.877 回答
35

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

int* a = new int[N];
// fill a

class C {
  const std::vector<int> v;
public:
  C():v(a, a+N) {}
};
于 2008-10-02T13:52:14.437 回答
25

在当前标准中是不可能的。我相信您将能够使用初始化列表在 C++0x 中执行此操作（请参阅Bjarne Stroustrup的 A Brief Look at C++0x，了解有关初始化列表和其他不错的 C++0x 功能的更多信息）。

于 2008-10-02T11:31:48.083 回答
13

std::vector使用堆。天哪，这只是为了进行const健全性检查而造成的浪费。重点std::vector是运行时的动态增长，而不是任何应该在编译时进行的旧语法检查。如果你不打算增长，那么创建一个类来包装一个普通数组。

#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()
{
    a x;
    x.print_items();
    return 0;
}

ConstFixedSizeArrayFiller并且ConstFixedSizeArray可以重复使用。

第一个允许在初始化数组时进行运行时边界检查（与向量可能相同），稍后可以const在此初始化之后进行。

第二个允许将数组分配在另一个对象内部，该对象可以在堆上，如果对象所在的位置，则可以简单地在堆栈上。从堆中分配不会浪费时间。它还对数组执行编译时常量检查。

b_filler是一个提供初始化值的小型私有类。数组的大小在编译时使用模板参数进行检查，因此不会超出范围。

我敢肯定有更多奇特的方法来修改它。这是一个初步的刺。我认为您几乎可以弥补编译器在类方面的任何缺点。

于 2010-04-15T04:21:07.973 回答
10

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 中具有不同的元素值，那么您正在制作尝试使数组 const 开始的错误。你应该这样做：

#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 << "v.a => " << v.a[0] << ", " << v.a[1] << "\n";
    return 0;
}
于 2008-10-02T11:50:26.320 回答
4

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

看看这个：

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

:)

于 2008-10-02T11:28:35.390 回答
4

在我有一个常量数组的地方，它总是作为静态的。如果您可以接受，则此代码应编译并运行。

#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;
}
于 2008-10-02T11:34:56.857 回答
3

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

#include <boost/array.hpp>

const boost::array<int, 2> aa={ { 2, 3} };

class A {
    const boost::array<int, 2> b;
    A():b(aa){};
};
于 2010-05-18T22:24:27.427 回答
3

如何通过访问器函数模拟 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:: 之外实际上是常量，您可以像访问数组一样访问它，例如

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

如果你愿意使用一对类，你可以额外保护 privateB 免受成员函数的影响。这可以通过继承a来完成；但我认为我更喜欢使用 const 类的 John Harrison 的 comp.lang.c++ 帖子。

于 2011-06-10T14:52:04.573 回答
2

有趣的是，在 C# 中，关键字 const 可以转换为 C++ 的静态 const，而不是 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", "!"};

但是，我没有找到绕过常量“10”的方法。原因很清楚，它需要它知道如何执行对数组的访问。一种可能的替代方法是使用#define，但我不喜欢该方法，并且我在标题末尾添加了#undef，并在CPP 中编辑注释以防发生更改。

于 2009-05-28T17:44:12.840 回答