相关疑难解决方法(0)

我知道引用是语法糖,因此代码更容易读写.

但有什么区别？

以下答案和链接摘要:

1. 指针可以重新分配任意次数,而在绑定后无法重新分配引用.
2. 指针可以指向nowhere(NULL),而引用总是指对象.
3. 您不能使用指针来获取引用的地址.
4. 没有"参考算术"(但您可以获取引用所指向的对象的地址,并对其进行指针运算&obj + 5).

澄清一个误解:

C++标准非常谨慎,以避免规定编译器如何实现引用,但每个C++编译器都将引用实现为指针.也就是说,声明如下:

int &ri = i;

Run Code Online (Sandbox Code Playgroud)

如果它没有完全优化,则分配与指针相同的存储量,并将地址i放入该存储中.

因此,指针和引用都使用相同数量的内存.

作为基本规则,

• 使用函数参数和返回类型中的引用来提供有用的自我文档化接口.
• 使用指针实现算法和数据结构.

有趣的读物:

• 我最喜欢的C++ FAQ lite.
• 参考与指针.
• 参考文献简介.
• 参考文献和常量.

我一直在研究C++ 11的一些新功能,我注意到的是在声明变量时使用的双符号,例如T&& var.

首先,这只野兽叫什么？我希望谷歌允许我们搜索这样的标点符号.

究竟是什么意思？

乍一看,它似乎是一个双重参考(如C风格的双指针T** var),但我很难想到一个用例.

C++ 0x显示了一个使用示例std::forward:

template<class T>
void foo(T&& arg) 
{
  bar(std::forward<T>(arg));
}

什么时候使用它std::forward总是有利的？

另外,它需要&&在参数声明中使用,它在所有情况下都有效吗？如果函数在其中声明,我认为你必须将临时函数传递给函数&&,那么可以使用任何参数调用foo吗？

最后,如果我有一个函数调用,如下所示:

template<int val, typename... Params>
void doSomething(Params... args) {
  doSomethingElse<val, Params...>(args...);
}

我应该用它代替:

template<int val, typename... Params>
void doSomething(Params&&... args) {
  doSomethingElse<val, Params...>(std::forward<Params>(args)...);
}

另外,如果在函数中使用两次参数,即同时转发到两个函数,是否明智使用std::forward？不会std::forward将相同的东西转换为临时两次,移动内存并使其无效以供第二次使用？以下代码是否可以:

template<int val, typename... Params>
void doSomething(Params&&... args) {
  doSomethingElse<val, Params...>(std::forward<Params>(args)...);
  doSomethingWeird<val, Params...>(std::forward<Params>(args)...);
}

我有点困惑std::forward,我很乐意使用一些清理工作.

可能重复:
使用forward的优点

我知道它的作用以及何时使用它但我仍然无法理解其工作原理.请尽可能详细,并解释std::forward如果允许使用模板参数推断,何时不正确.

我的一部分困惑是:"如果它有一个名字,它就是一个左值" - 如果是这样的话,为什么std::forward当我通过thing&& xvs 时表现不同thing& x？

我只是编写一个通用对象工厂并使用boost预处理器元库来创建一个可变参数模板(使用2010并且它不支持它们).我的函数使用rval引用并std::forward进行完美的转发,它让我思考...当C++ 0X出来并且我有一个标准编译器时,我会使用真正的可变参数模板.但是,我怎么称呼std::forward这些论点？

template <typename ...Params>
void f(Params... params) // how do I say these are rvalue reference?
{
    y(std::forward(...params)); //? - I doubt this would work.
}

我能想到的唯一方法就是需要手动拆包... params,我也不是那里.是否有更快的语法可行？

可能重复:
使用forward的优点

有人可以向我解释一下完美的转发是什么意思吗？

我正在寻找的代码如下.

bool Func1(int Arg1, C++11LambdaFunc Arg2){
    if(Arg1 > 0){
        return Arg2(Arg1);
    }
}

稍后我将使用此代码.

Func1(12, [](int D) -> bool { ... } );

C++ 11(和C++ 14)引入了针对通用编程的其他语言结构和改进.这些功能包括:

• R值参考
• 参考折叠
• 完美转发
• 移动语义,可变参数模板等

我在浏览较早草案的的C++ 14规范(现在更新文本)和码中的示例中§20.5.1,编译时整数序列,我发现有趣和奇特.

template<class F, class Tuple, std::size_t... I>
decltype(auto) apply_impl(F&& f, Tuple&& t, index_sequence<I...>) {
  return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
}

template<class F, class Tuple>
decltype(auto) apply(F&& f, Tuple&& t) {
  using Indices = make_index_sequence<std::tuple_size<Tuple>::value>;
  return apply_impl(std::forward<F>(f), std::forward<Tuple>(t), Indices());
}

在线这里[intseq.general]/2.

题

• 为什么功能f在apply_impl被转发,即为什么std::forward<F>(f)(std::get...？
• 为什么不直接应用该功能f(std::get...？

C++ 11模式下的GCC 4.7让我定义了一个以两种不同方式获取lambda的函数:

// by value
template<class FunctorT>
void foo(FunctorT f) { /* stuff */ }

和:

// by r-value reference
template<class FunctorT>
void foo(FunctorT&& f) { /* stuff */ }

但不是:

// by reference
template<class FunctorT>
void foo(FunctorT& f) { /* stuff */ }

我知道我可以取消模板化函数,只需要使用std :: functions,但是foo它很小并且内联,我想给编译器提供最好的机会来内联调用它.在前两个中,如果我特别知道我正在传递lambdas,那么这对性能来说是优选的,为什么不允许将lambda传递给最后一个？

我想将一个rvalue传递std::bind给一个在C++ 0x中采用rvalue引用的函数.我无法弄清楚该怎么做.例如:

#include <utility>
#include <functional>

template<class Type>
void foo(Type &&value)
{
    Type new_object = std::forward<Type>(value);    // move-construct if possible
}

class Movable
{
public:
    Movable(Movable &&) = default;
    Movable &operator=(Movable &&) = default;
};

int main()
{
    auto f = std::bind(foo<Movable>, Movable());
    f();    // error, but want the same effect as foo(Movable())
}