标签: member-initialization

我一直在经历' A Tour of C++ ',Bjarne在构造函数的成员初始化中使用了c ++ 11初始化列表功能,就像这样(使用花括号):

A a;
B b;
Foo(Bar bar):
  a{bar.a}, b{bar.b}
{}

但是,这不会在c ++ 11之前编译.与旧成员初始化列表有什么区别(使用圆括号):

Foo(Bar bar):
  a(bar.a), b(bar.b)
{}

那么有什么区别,什么时候应该优先于另一个呢？

有这个结构:

struct A {
    struct B {
        int a = 21;
        int b;
        int c = 22;
        int d;
        int e = 23;
    };
    B b1  = { 11, 12 };
    B b2  = { 11, 12, 13 };
    int x;
};

并声明:

A a = { { 1, 2, 3, 4 }, { 1 }, 5 };

根据Clang(3.8.0)和GCC(5.4.0),这些是8种可能组合的值(a.b1.e和a.b2.a是重复的情况),关于初始值的位置从(或不),:

a.b1.a = 1   // 111
a.b1.b = 2   // 110
a.b1.c = 3   // 101
a.b1.d = 4   // 100
a.b2.b …

我只是制作了一个示例，从我个人的角度来看，该示例不应编译或至少发出警告，但Visual Studio 2017不给出任何警告。示例如下：

#include <stdexcept>

struct Foo {
    Foo(int i) { throw std::runtime_error("Oh no:("); }
    Foo(float f) {}
};

struct Bar {
    Bar() {}
};

struct Baz {
    Baz() : foo(5.0f) {}

    Bar bar;
    Foo foo = Foo(3);
    Bar bar2;
};

int main()
{
    Baz baz;
}

以我的观点（但我不是语言律师），foo的两个初始化（就地与初始化列表）是模棱两可的。那么在这种情况下有什么规则？

我有这个:

struct myClass{
    multiset<string,binPred<string> > values ;

    myClass(const char param1, const char param2) : values(less<string>())
    { }
} ;

我需要的初始化values成员有根据的值不同的函子param1和param2.不幸的是,决定使用哪个仿函数的逻辑并不那么简单,而且一旦values构造我就无法改变它的相关比较仿函数.

所以...我需要将所有决策逻辑放在成员初始化部分,但我不知道如何使用?:运算符.
是否有可能在那里放置更复杂的陈述？(像switchstaments)

如果没有,有没有办法延迟构造,values所以我可以在构造函数的主体中初始化它？

谢谢.

嗨我有一个带把手的余烬应用程序if else语句总是显示if部分而不是其他

我已经阅读了这里和这里的余烬文档中的所有内容, 并在网上无数次搜索:(

我的控制器和模板的代码显示在下面我认为问题可能与我的控制器引用未在控制器之前加载的会话初始化程序有关？

我已经阅读了这里和这里 以及我忘记的许多其他地方:(试图学习如何在我的控制器之前加载初始化器

下面是我的应用程序控制器和我的应用程序模板的代码

 <nav role="navigation" class="navbar navbar-default navbar-fixed-top">
    <div class="container-fluid">
        <!-- Brand and toggle get grouped for better mobile display -->
        <div class="navbar-header">
            <button type="button" data-target="#navbarCollapse" data-toggle="collapse" class="navbar-toggle">
                <span class="sr-only">Toggle navigation</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            {{#link-to "index" class="navbar-brand"}}Hide The Word{{/link-to}}
        </div>
        <!-- Collection of nav links and other content for toggling -->
        <div id="navbarCollapse" class="collapse navbar-collapse">
            <ul class="nav navbar-nav">
              {{#if 'registered'}}
                <li>{{#link-to "user" userId}}{{user}}{{/link-to}}</li>
                <li>{{#link-to …

这部分是一个风格问题，部分是一个正确性问题。提交以下示例（处理包含嵌入标头的数据块的类的精简）：

class Foo {
 public:
  Foo(size_t size)
      : scratch_(new uint8_t[header_length_ + size]),
        size_(header_length_ + size) {
  }
  ~Foo() {
    delete[] scratch_;
  }
  Foo(const Foo&) = delete;  // Effective C++
  void operator=(const Foo&) = delete;  // Effective C++
 protected:
  struct Header {
    uint32_t a, b, c, d;
  };
  uint8_t * const scratch_;
  size_t const size_;
  Header * const header_ = reinterpret_cast<Header *>(scratch_);
  static constexpr size_t header_length_ = sizeof(Header);
  static constexpr size_t data_offset_ = header_length_;
  size_t const data_length_ = size_ - data_offset_; …

我创建了一个类Point，这里是对应的hpp文件。

#ifndef POINT
#define POINT
class Point
{
 protected:
 int x;
 int y;
 public:
 Point(int x = 10, int y = 10);
 void movePoint(int moveX, int moveY);
 void printCoordinates();
};
#endif

我注意到在 main 中，我可以声明一个对象并以这种方式初始化它：

Point myPoint(1, 1);

如果我想创建一个包含两个点的结构，它不会让我以这种方式初始化它，相反，我必须使用大括号，这样：

struct segment
{
 Point point1 = {0, 0};
 Point point2 = {15, 15};
};

这是为什么？

我可以毫无问题地编译以下代码（使用 gcc 11.1.0）：

#include <iostream>\n\ntemplate <typename Func>\nclass K {\n    Func f;\npublic:\n    K(Func _f): f{_f} {};\n    void do_thing(int x) {f(x);};\n};\n\nint main()\n{\n    auto f = [](int x) {std::cout << x << std::endl;};\n    K kl{f};\n    kl.do_thing(5);\n\n    return 0;\n}\n

但是我想在类的构造函数中执行一些检查K（例如某些函数std::is_convertible_v内部的一些bool检查），所以我尝试将代码修改为

#include <iostream>\n\ntemplate <typename Func>\nclass K {\n    Func f;\n    \npublic:\n    K(Func _f) {\n    ...\n    f = _f;};\n    void do_thing(int x) {f(x);};\n};\n\nint main()\n{\n    auto f = [](int x) {std::cout << x << std::endl;};\n    K kl{f};\n    kl.do_thing(5);\n\n    return …

在多次简化我的代码后，我发现了以下问题的原因。

class B {
public:
    B(const int x)
              :_x(x) {}
    const int _x;
};

class C {
public:
    C(const B& b) 
        : _b(b), _b2(_b._x) {}
    B _b2;       // line 1
    const B& _b; // line 2
};

int main() {
    B b(1);
    C c(b);
}

警告 (clang 8.0.0)

test16.cpp:11:22: warning: reference '_b' is not yet bound to a value when used here [-Wuninitialized]
        : _b(b), _b2(_b._x) {}
                     ^
1 warning generated.

g++-6 编译程序。运行该程序会导致分段错误。

类成员的初始化是遵循成员初始化列表: _b(b), _b2(_b._x)的顺序（）还是类中成员的顺序（如B _b2; …

例如，我有一个名为 的类Vector表示向量，还有一个名为 的类Integer表示整数。

class Integer{
public:
   Integer(int v):value_(v){};
private:
   int value_;
};
template<uint32_t Dim>
class Vector{
public:
     Vector(int v[Dim]) 
      ://How to initialize each element of the value_ array here?
     {
     }
private:
     Integer value_[Dim];
}

由于Integer没有默认构造函数，因此必须value_在 的成员初始值设定项列表中初始化数组的每个元素Vector。但是，由于数组的长度是模板参数，因此不能直接使用类似value_{v[0], v[1], v[2]}value_ 数组的东西来初始化。我正在使用c++14。