小编Xeo*_*Xeo的帖子

因此,在观看了关于右值引用的精彩演讲之后,我认为每个类都会受益于这样的"移动构造函数",template<class T> MyClass(T&& other) 编辑,当然还有"移动赋值运算符",template<class T> MyClass& operator=(T&& other)正如Philipp在他的回答中指出的,如果它已经动态分配成员,或通常存储指针.就像你应该有一个copy-ctor,赋值运算符和析构函数,如果之前提到的点适用.思考？

我遇到了以下程序,它编译时没有错误甚至是警告:

int main(){
  <:]{%>; // smile!
}

实例.

程序做了什么,笑脸表达是什么？

我有一个带有一些参数的构造函数.我假设它们是按照列出的顺序构建的,但在一种情况下,它们似乎是反向构造的,导致中止.当我颠倒论点时,程序停止了中止.这是我正在使用的语法的一个例子.问题是,在这种情况下,需要在b_之前初始化a_.你能保证施工顺序吗？

例如

class A
{
  public:
    A(OtherClass o, string x, int y) :
      a_(o), b_(a_, x, y) { }

    OtherClass a_;
    AnotherClass b_;
};

为什么std::make_unique标准C++ 11库中没有函数模板？我发现

std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3));

有点冗长.以下不是更好吗？

auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3);

这隐藏得new很好,只提到一次类型.

无论如何,这是我尝试实现make_unique:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

我花了很std::forward长时间来编译这些东西,但我不确定它是否正确.是吗？究竟是什么std::forward<Args>(args)...意思？编译器对此做了什么？

@R的答案.Martinho Fernandes表示,在C++ 11中,安全布尔的习语显然已被弃用,因为它可以被简单的替换

explicit operator bool() const;

根据答案中的标准引用§4 [conv] p3:

对于某些发明的临时变量(§8.5),T当且仅当声明T t=e;格式正确时,表达式e才能隐式转换为类型t.某些语言结构要求将表达式转换为布尔值.对于某些发明的临时变量t(§8.5),当且仅当声明格式正确时,表示出e现在这样的上下文中的表达被上下文转换为bool并且格式良好bool t(e);.

突出显示的部分清楚地显示了"隐式显式转换"(在标准中称为"上下文转换")为@R.马蒂纽说.

需要"隐式显式强制转换"的"某些语言结构"似乎如下:

• if,while,for(§6.4 [stmt.select] p4)
• 二元逻辑运算符&&和||(§5.14 [expr.log.and/or] p1两者)
• 逻辑否定运算符!(§5.3.1 [expr.unary.op] p9)
• 条件运算符?:(§5.14 [expr.cond] p1)
• static_assert(§7 [dcl.dcl] p4)
• noexcept(§15.4 [except.spec] p2 …

我想写这个

typedef void (*FunctionPtr)();

使用using.我该怎么办？

(注意:这个问题是不必指定元素的数量,仍然允许直接初始化嵌套类型.)
这个问题讨论了C数组的用途int arr[20];.在他的回答中,@ James Kanze展示了C阵列的最后一个据点,它具有独特的初始化特性:

int arr[] = { 1, 3, 3, 7, 0, 4, 2, 0, 3, 1, 4, 1, 5, 9 };

我们没有必要指定元素的数量,万岁!现在遍历它与C++ 11的功能std::begin和std::end从<iterator>(或您自己的变体),你永远需要甚至认为它的大小.

现在,有没有(可能是TMP)方法实现同样的目标std::array？使用宏可以使它看起来更好.:)

??? std_array = { "here", "be", "elements" };

编辑:中间版本,从各种答案编译,如下所示:

#include <array>
#include <utility>

template<class T, class... Tail, class Elem = typename std::decay<T>::type>
std::array<Elem,1+sizeof...(Tail)> make_array(T&& head, Tail&&... values)
{
  return { std::forward<T>(head), std::forward<Tail>(values)... };
}

// in code …

我首先学习了C#,现在我开始使用C++.据我所知,newC++中的operator 与C#中的operator 不相似.

你能解释一下这个示例代码中内存泄漏的原因吗？

class A { ... };
struct B { ... };

A *object1 = new A();
B object2 = *(new B());

^{(对于类型擦除,我的意思是隐藏有关类的一些或所有类型信息,有点像Boost.Any.)}
我想要掌握类型擦除技术,同时也分享那些,我知道.我希望找到一些有人在他/她最黑暗的时刻想到的疯狂技巧.:)

我所知道的第一个也是最明显的,也是最常用的方法是虚函数.只需在基于接口的类层次结构中隐藏类的实现.许多Boost库都这样做,例如Boost.Any这样做是为了隐藏你的类型,而Boost.Shared_ptr这样做是为了隐藏(de)分配机制.

然后有一个函数指针指向模板化函数的选项,同时将实际对象保存在void*指针中,如Boost.Function确实隐藏了仿函数的实际类型.可以在问题的最后找到示例实现.

所以,对于我的实际问题:
你知道其他什么类型的擦除技术？如果可能的话,请提供示例代码,用例,您对它们的体验以及可能的进一步阅读链接.

编辑
(因为我不确定是否将此作为答案添加,或者只是编辑问题,我只会做更安全的问题.)
另一个很好的技术来隐藏没有虚函数或void*摆弄的东西的实际类型,是一个GMan在这里工作,与我的问题有关,这个问题究竟是如何运作的.

示例代码:

#include <iostream>
#include <string>

// NOTE: The class name indicates the underlying type erasure technique

// this behaves like the Boost.Any type w.r.t. implementation details
class Any_Virtual{
        struct holder_base{
                virtual ~holder_base(){}
                virtual holder_base* clone() const = 0;
        };

        template<class T>
        struct holder : holder_base{
                holder()
                        : held_()
                {} …

考虑具有可变参数模板参数的模板化函数的情况:

template<typename Tret, typename... T> Tret func(const T&... t);

现在,我有一个t价值元组.如何func()使用元组值作为参数调用？我已经阅读了bind()函数对象,call()函数,以及apply()不同的一些现在过时的文档中的函数.GNU GCC 4.4实现似乎call()在bind()类中有一个函数,但是关于这个主题的文档很少.

有些人建议使用手写的递归黑客,但可变参数模板参数的真正价值在于能够在上述情况下使用它们.

有没有人有解决方案,或提示在哪里阅读它？