标签: uniform-initialization

C++

cout构造和销毁此类消息的对象.我试图使用只有类名的声明来构造一个临时对象,但它给出了一个意外的输出.

在#1中,我使用括号实例化一个临时无名对象.

在#2中,我使用统一初始化实例化一个临时无名对象.

我不知道#3是否会编译.我只想到如果编译#3,它将表示临时无名对象的构造.它确实编译,但是从#3下控制台输出的空白处看不到构造对象.这里发生了什么？

#include <iostream>

class A
{
public:
    A() {std::cout << "constructed\n";}
    ~A() {std::cout << "destroyed\n";}
};

auto main() -> int
{
    std::cout << "#1:\n";
    A();
    std::cout << "#2:\n";
    A{};
    std::cout << "#3:\n";
    A;
    return 0;
}

控制台输出:

#1:
constructed
destroyed
#2:
constructed
destroyed
#3:

注意:这是在2012年11月CTP的VC11中编译的.它不能在g ++ 4.8.0或clang 3.2中编译,它们分别给出error: declaration does not declare anything [-fpermissive]和fatal error: 'iostream' file not found.

我正在尝试实例化一组这样的字符串:

class POI {
public:
...
  static const std::set<std::string> TYPES { "restaurant", "education", "financial", "health", "culture", "other" };
...
}

现在,当我这样做时,我得到了这些错误(全部都在这一行):

error: field initializer is not constant
 static const std::set<std::string> TYPES { "restaurant", "education", "financial", "health", "culture", "other" };
error: in-class initialization of static data member 'const std::set<std::basic_string<char> > POI::TYPES' of non-literal type
error: non-constant in-class initialization invalid for static member 'POI::TYPES'                                                              
error: (an out of class initialization is required)
error: 'POI::TYPES' cannot be initialized by a non-constant expression when …

所以我们假设我有以下课程

class NoDefaultConstructor {
    NoDefaultConstructor() = delete;
    ...
};

我有另一个类,有一个类型NoDefaultConstructor和其他成员的数组

class Wrapper {
    std::array<NoDefaultConstructor, 2> arr;
    ... 
};

如何在构造函数中初始化数组Wrapper(可能在初始化列表中使用std::intializer_list)？

更具体地说,是我可以将参数传递给初始化列表中的数组构造函数Wrapper以获得类似于以下的构造的唯一方法吗？我正在考虑这样做,因为数组的大小将来可能会改变.

template <typename... Values>
Wrapper(Values&&... values) : arr{std::forward<Values>(values)...} {}

我有一个POD ChParam,它是可变参数模板函数中的一个参数set.我想在花括号中传递函数参数(构造函数参数)p.set({ Param::D, 1000.f }, { Param::p, 2000.f }).并且认为构造函数将被隐式调用,并且ChParam将创建对象.但这是不可能的,我应该明确地创建一个对象a.set(ChParam{ Param::D, 1000.f }, ChParam{ Param::p, 2000.f });

有可能以某种方式使用变体p.set({ Param::D, 1000.f }, { Param::p, 2000.f })吗？

#include <iostream>
using namespace std;

using Float = float;

enum class Param : size_t
{
    D = 0,
    p
};
struct ChParam
{
    Param tag_;
    Float value_;
};
class PipeCalcParams
{
private:
    Float D_, p_;
public:
    PipeCalcParams() : D_(0), p_(0) {}
    PipeCalcParams& set_D(Float D) { D_ …

以下代码不使用clang ++ 3.8.0和g ++ 6.3.0(编译器标志-std=c++11 -Wall -Wextra -Werror -pedantic-errors)编译:

int main()
{
    int* a = int*{}; // doesn't compile
    //       ^^^^ can't be parsed as a type
    (void)a;

    using PInt = int*;

    PInt b = PInt{}; // compiles successfully
    //       ^^^^ is parsed as a type
    (void)b;
}

它是一种强制int*{}编译器以正确的方式在这里解释(typedef荷兰国际集团的int*是这样的一种方式)？

我已经打了很多新的统一初始化用{}.像这样:

vector<int> x = {1,2,3,4};
map<int,string> getMap() {
    return { {1,"hello"}, {2,"you"} };
}

毫无疑问,这种初始化可能会改变我们的程序C++.但是我想知道在Herb Sutter常见问题解答中阅读Alfonses的问题时我是否错过了一些神奇的可能性.

Alfonse:统一初始化(在推导构造的类型时使用{}调用构造函数)有可能从根本上减少创建C++类型所需的键入数量.就像lambdas一样,它会改变人们编写C++代码的方式.[...]

有人能给我一个Alfonse在这里设想的例子吗？

考虑用GCC 4.7.2编译的这个简短程序 g++ -std=c++11 test.cc

#include <memory>
#include <queue>

struct type{
  type(int a) : v(a) {}
  int v;
};

typedef std::shared_ptr<type> type_ptr;

int main(){
  int value = 3;
  std::queue<type_ptr> queue;
  auto ptr{std::make_shared<type>(value)};
  queue.push(ptr);
}

编译器输出以下错误:

src/test.cc: In function ‘int main()’:
src/test.cc:15:17: error: no matching function for call to ‘std::queue<std::shared_ptr<type> >::push(std::initializer_list<std::shared_ptr<type> >&)’
src/test.cc:15:17: note: candidates are:
In file included from /usr/include/c++/4.7/queue:65:0,
                 from src/test.cc:2:
/usr/include/c++/4.7/bits/stl_queue.h:211:7: note: void std::queue<_Tp, _Sequence>::push(const value_type&) [with _Tp = std::shared_ptr<type>; _Sequence = std::deque<std::shared_ptr<type>, std::allocator<std::shared_ptr<type> > >; std::queue<_Tp, _Sequence>::value_type …

这是有问题的代码示例:

struct A {
    A() = delete;
};

int main()
{
//  A a(); // compiles, since it's a function declaration (most vexing parse)
//  A a;   // does not compile, just as expected
    A a{}; // compiles, why? The default constructor is deleted.
}

在这里尝试使用任何可用的编译器.我尝试了几个,没有找到一个编译错误.

我是统一初始化的忠实粉丝,在大多数情况下,当我想构建初始化变量时,我正在使用它.最近,当我构建变量类型时,我遇到了奇怪的错误cv::Mat.

cv::Mat lookUpTable( 1, 256, CV_8U );
uchar* p = lookUpTable.ptr();

for( int i = 0; i < 256; ++i )
{
    p[i] = cv::saturate_cast<uchar>( pow( i / 255.0, gamma ) * 255.0 );
}

虽然此实现很有效,但如果使用统一初始化

cv::Mat lookUpTable{ 1, 256, CV_8U };

出现以下错误

malloc_consolidate():块大小无效

我仍然不确定发生了什么.是否使用了不同的构造函数(假设)？有人可以进一步解释吗？

const int number{42};

这是有效的语法吗？我只能找到花括号初始值设定项用于对象或非平凡类型的示例.