标签: initialization-list

struct B { int b1, b2;  B(int, int); };
struct D : B {
  int d1, d2;
// which is technically better ?
  D (int i, int j, int k, int l) : B(i,j), d1(k), d2(l) {} // 1st Base
// or
  D (int i, int j, int k, int l) : d1(k), d2(l), B(i,j) {} // last Base
};

以上只是伪代码.实际上我想知道调用基础构造函数的顺序是否重要？ 是否有任何不良行为(特别是拐角案件)由任何案件引起？我的问题是更多的技术方面,而不是编码风格.

这种情况与如何对构造函数的参数进行约束有关,但它略有不同.

您想要初始化非默认可构造成员,但需要在构造之前检查约束.

例:

(请注意,这只是一个例子.在这种特定情况下是否应该使用无符号整数是可以讨论的,但问题实际上是关于你想检查构造函数的一般情况)

你有以下课程:

class Buffer {
public:
    Buffer() = delete;
    Buffer(int size) noexcept;
};
....


class RenderTarget {
public:
    ....
private:
    int width_, height_;
    Buffer surface_;
};

构造函数必须检查整数参数的有效性:

RenderTarget::RenderTarget(int width, int height) :
    width_(width), height_(height),
    surface_(width_*height)
{
    if (width_<0 || height_<0)
        throw std::logic_error("Crizzle id boom shackalack");
}

注意如何Buffer没有默认构造函数,而真正的构造函数是noexcept,即没有办法捕获错误.

当整数参数为负数时,已经有一个surface_已经加了.在使用约束值之前进行约束检查会更好.可能吗？

考虑初始化列表构造函数用法的这个示例:

std::vector<std::string> v = { "xyzzy", "plugh", "abracadabra" };
std::vector<std::string> v({ "xyzzy", "plugh", "abracadabra" });
std::vector<std::string> v{ "xyzzy", "plugh", "abracadabra" }; 

它们之间是否有任何差异(甚至是轻微的)？

在一个大型项目中,您必须定义一个标准,您会选择哪种样式？
我更喜欢第一种风格,第三种风格很容易与使用args的构造函数调用混淆.第一种风格看起来也很熟悉其他编程语言.

我有一个关于如何在初始化列表中捕获异常的问题.

例如,我们有一个派生自Bar的Foo类

class Foo {

public:
Foo(int i) {throw 0; }

}

class Bar : public Foo{

public:

Bar() : Foo(1) {}

}

我有这个例子来生成一个向量中的唯一对象:

#include <iostream>
#include <vector>
#include <algorithm>

int v=0;

struct A
{
    A() : refValue( v++)
    { std::cout<<"constructor refValue="<<refValue<<std::endl; }
    A( const A &r ) : refValue(r.refValue)
    { std::cout<<"copy constructor refValue="<<refValue<<std::endl; }
    A& operator=( const A &r )
    {
        refValue = r.refValue;
        std::cout<<"operator= refValue="<<refValue<<std::endl;
        return *this;
    }
    ~A() { std::cout<<"destructor refValue="<<refValue<<std::endl; }

    int refValue;
};

A GenerateUnique()
{
    A unique;
    return unique;
}
struct B
{
    B( const int n) : v()
    {
        std::generate_n( std::back_inserter( v ), n, &GenerateUnique ); …

我正在尝试学习如何初始化列表.

我在下面有一个简单的类,并尝试初始化变量列表.第一Month(int m): month(m)部作品.我正在尝试使用多个变量在该行下面执行类似的操作.这种格式有可能吗？我是否必须脱离一个班轮？

class Month
{
public:
    Month(int m) : month(m) {} //this works
    Month(char first, char second, char third) : first(first){} : second(second){} : third(third){} //DOES NOT WORK
    Month();
    void outputMonthNumber(); //void function that takes no parameters
    void outputMonthLetters(); //void function that takes no parameters
private:
    int month;
    char first;
    char second;
    char third;
};

显然我没有太多线索如何做到这一点,任何指导将不胜感激,谢谢

虽然我非常喜欢C++ 11中的新功能,但有时我觉得我错过了一些细微之处.

初始化int数组工作正常,初始化Element2向量工作正常,但初始化Element2数组失败.我认为正确的语法应该是未注释的行,但没有一个初始化尝试成功.

#include <array>
#include <vector>

class Element2
{
    public:
            Element2(unsigned int Input) {}
            Element2(Element2 const &Other) {}
};

class Test
{
    public:
            Test(void) :
                    Array{{4, 5, 6}},
                    Array2{4, 5},
                    //Array3{4, 5, 6}
                    Array3{{4, 5, 6}}
                    //Array3{{4}, {5}, {6}}
                    //Array3{{{4}, {5}, {6}}}
                    //Array3{Element2{4}, Element2{5}, Element2{6}}
                    //Array3{{Element2{4}, Element2{5}, Element2{6}}}
                    //Array3{{{Element2{4}}, {Element2{5}}, {Element2{6}}}}
                    {}
    private:
            std::array<int, 3> Array;
            std::vector<Element2> Array2;
            std::array<Element2, 3> Array3;
};

int main(int argc, char **argv)
{
    Test();
    return 0;
}

我在MinGW下的g ++ 4.6.1和4.6.2上尝试了这个.

我应该如何正确地初始化这个数组？可能吗？

问题:

我有一个奇怪的问题,我没想到.我有一个名为Answers的类,在标题内是这样的:

class Answer
{
    char* aText;
    bool b_correct;
public:
    Answer():aText(0){;}  //default constructor
}

主(测试)驱动程序代码是这样的:

int main(void) 
{

    static const unsigned int MAX_ANSWERS = 5;
    Answer answers[MAX_ANSWERS];
}

我得到的(意外)怪异是发生了一个分配,我还没有在我的代码中使用任何新的东西.我猜测char*在初始化列表中调用它.

我使用valgrind来测试我的代码,我得到11个allocs和10个frees.当我删除初始化器时:aText(0),额外的alloc消失了.

我知道这是构造糟糕的代码.我正在学习如何用C++编写课程大纲.有人可以帮我理解内存的分配方式或初始化列表中发生的事情,以便调用新的内容吗？

我知道错误来自显示的代码.我知道额外的alloc正在发生当我编译并运行这个代码时.

Valgrind输出:

==12598== Memcheck, a memory error detector
==12598== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==12598== Using Valgrind-3.10.1 and LibVEX; rerun with -h for copyright info
==12598== Command: ./Answers
==12598== 
==12598== 
==12598== HEAP SUMMARY:
==12598==     in use at exit: 72,704 bytes in …

可以通过函数获取的元组在成员初始化列表中初始化多个成员吗？

通过元组返回多个值变得越来越流行,我希望有一个解决方案.我认为除了语言限制之外没有任何理由为什么这是不可能的.

这是我所拥有的:

auto new_foo(std::size_t size) -> std::tuple<std::unique_ptr<char[]>, int*>
{
    auto buffer = std::make_unique<char[]>(size * sizeof(int) + 8);
    auto begin = static_cast<int*>(static_cast<void*>(buffer.get() + 4));
    return std::make_tuple(std::move(buffer), begin);
}

struct X {
    std::unique_ptr<char[]> buffer_{nullptr};
    int* begin_{nullptr};
    std::size_t size_{0};

    X(std::size_t size) : size_{size}
    {
        std::tie(buffer_, begin_) = new_foo(size);
    }
};

可以这样做吗？:

    X(std::size_t size)
        : buffer_{ ??? },
          begin_{ ??? },
          size_{size}
    {
    }

我无法new_foo 为每个成员初始化调用一次(因为它会在每次调用时返回另一个元组).所以

    X(std::size_t size)
        : buffer_{std:get<0>(new_foo(size)},
          begin_{std:get<1>(new_foo(size)},
          size_{size}
    {
    }

这是不可能的(即使不是这种情况,多次调用以获得相同的结果也不是最佳的)

我想到的另一个解决方案是将成员作为一个元组.我放弃了,因为我需要在类中正确命名的两个成员,而不是使用get<0>和访问get<1>. …

变量有什么问题international_standard_book_number？我怎样才能让它改变，无论何时isbn_field_i改变？

#include <iostream>
#include <string>

class ISBN
{
private:
  unsigned int isbn_field_1 = 0;
  unsigned int isbn_field_2 = 0;
  unsigned int isbn_field_3 = 0;
  char digit_or_letter = 'a';
  std::string international_standard_book_number =
    std::to_string(isbn_field_1) + "-" + std::to_string(isbn_field_2) + "-" +
    std::to_string(isbn_field_3) + "-" + digit_or_letter;

public:
  ISBN()
  {
    isbn_field_1 = 0, isbn_field_2 = 0, isbn_field_3 = 0, digit_or_letter = 'a';
  }
  ISBN(unsigned int a, unsigned int b, unsigned int c, char d)
  {
    isbn_field_1 = a, isbn_field_2 …