小编Nik*_*iou的帖子

在c ++ 14 decltype(auto)中引入了成语.

通常,它的用途是允许auto声明使用decltype给定表达式的规则.

搜索成语的"好"用法示例我只能想到以下内容(由Scott Meyers提供),即函数的返回类型推导:

template<typename ContainerType, typename IndexType>                // C++14
decltype(auto) grab(ContainerType&& container, IndexType&& index)
{
  authenticateUser();
  return std::forward<ContainerType>(container)[std::forward<IndexType>(index)];
}

这个新语言功能有用吗？

C++标准委员会倾向于回避在该语言中添加新的关键字,但C++ 11并非如此.一些例子:

constexpr
decltype
thread_local
auto // New usage
noexcept
nullptr
static_assert
alignof
alignas

C++ 14是否引入了新的关键字？

当想要执行一个副本(1. doable with copy_if)但是从一个容器值到一个指向这些值的指针容器(2.可行transform)时,就出现了一个用例.

可用的工具,我不能做到这一点,在不到两个步骤:

#include <vector>
#include <algorithm>

using namespace std;

struct ha { 
    int i;
    explicit ha(int a) : i(a) {}
};

int main() 
{
    vector<ha> v{ ha{1}, ha{7}, ha{1} }; // initial vector
    // GOAL : make a vector of pointers to elements with i < 2
    vector<ha*> ph; // target vector
    vector<ha*> pv; // temporary vector
    // 1. 
    transform(v.begin(), v.end(), back_inserter(pv), 
        [](ha &arg) { return &arg; }); 
    // 2. 
    copy_if(pv.begin(), pv.end(), …

鉴于c ++许多程序员提供的新工具集,旨在实现代码简化,表达性,效率,浏览旧代码并进行调整(有些无意义,有些成功)以实现他们的目标.尽管不要在这些工作上浪费太多时间,只是做出非侵入性和自包含的变化,但最佳做法是什么？

让我勾勒出明显的:

• 使用auto运行基于迭代器的循环:

  for (std::vector<foo>::const_iterator it(lala.begin()), ite(lala.end()); it != ite;     
  ++it);
  // becomes
  for (auto it(lala.cbegin()), ite(lala.cend()); it != ite; ++it);
  

  Run Code Online (Sandbox Code Playgroud)

• 使用tie来进行多个赋值,这些赋值只产生C风格的代码行(如何一次将多个值分配到结构中？)

  a = 1;
  b = 2; 
  c = 3;
  d = 4; 
  e = 5;
  // becomes
  std::tie(a, b, c, d, e) = std::make_tuple(1, 2, 3, 4, 5);
  

  Run Code Online (Sandbox Code Playgroud)

• 要使类不可继承,只需将其声明为"final"并删除实现此类行为的代码http://www.parashift.com/c++-faq/final-classes.html

• 使用delete关键字显式隐藏构造函数/析构函数,而不是将它们声明为私有(例如,用于创建基于堆的对象的代码,不可复制的对象等)

• 创建简单的仿函数只是为了将单个STL算法的执行变为lambda函数(除了减少代码混乱,你还能保证内联调用)

• 仅使用智能指针简化对象的RAII包装

• 摆脱bind1st,bind2nd只需使用bind

• 用<type_traits>提供的标准代码替换类型特征的手写代码(Is_ptr_but_dont_call_for_const_ptrs <>等:))

• 停止包含现在在STL中实现的函数的boost标头(BOOST_STATIC_ASSERT vs static_assert)

• 为类提供移动语义(虽然这不符合脏/快/易更改的条件)

• 在可能的情况下使用nullptr而不是NULL宏,并删除填充指针的容器的代码,其中0已转换为对象类型

  std::vector<foo*> …

  Run Code Online (Sandbox Code Playgroud)

有没有办法在未命名的类中声明构造函数或析构函数？考虑以下

void f()
{
    struct {
        // some implementation
    } inst1, inst2;

    // f implementation - usage of instances
}

后续问题:实例是基于任何基于堆栈的对象构造(和销毁)的.叫什么？它是由编译器自动分配的错位名称吗？

介绍

让我们假设我们有一个类似于以下类型的线性层次结构:

然后我想要的是一种机制,从该谱系中的任意数量的类型返回最低共同祖先.

试图代码

template<typename...Ts>
struct LCA;

template<typename T1, typename T2, typename...Ts>
struct LCA<T1, T2, Ts...>
{
    using base = typename std::conditional
    <
        std::is_base_of<T1, T2>::value, T1,
        typename std::conditional <
            std::is_base_of<T2, T1>::value, T2, void
        >::type
    >::type;

    using type = typename LCA<base, Ts...>::type;
};

template<typename T>
struct LCA<T>
{
    using type = T;
};

现场演示

用例

我的用例是相当典型的:在制作一些iterator工具时我想提取"限制性最强"的迭代器类型,因此迭代器中存在(种类)线性层次结构,我应该能够根据需要提升层次结构:

LCA<Bidirectional, RandomAccess, RandomAccess> -> Bidirectional
LCA<RandomAccess, Input, Forward>              -> Input

问题

1. 是否有更简洁/惯用的方法来处理错误情况,其中两个或更多类型是层次结构的陌生人？目前的方法是返回void …

有一些已知的方法来操纵整数文字的类型

0L;  // long
3U;  // unsigned integer
1LL; // long long

我需要的是一种初始化整数文字的方法std::size_t.我以为这样做

2U; // unsigned int

就足够了,但是在调用函数模板时仍然会遇到编译器错误,该函数模板需要两个相同整数类型的参数(没有匹配的函数可以调用func(unsigned int, size_t)

我知道/验证显式cast(static_cast<std::size_t>(1))第一个参数解决了问题,但我在问是否有更漂亮的解决方案

编辑

该功能有签名

template <class T> const T& func(const T& a, const T& b);

EDIT2

我不知道这个问题是否是"责备",但我很高兴地宣布这是即将到来的(在评论中提到这个问题的@malat)

以下看起来像编译错误:

struct : Base { };

然而,当使用 ^[1]它似乎工作:

#include <iostream>
using namespace std;

template<bool B>
struct A 
{
    struct : std::integral_constant<bool, B> {
    } members;
};

int main()
{
    A<true> a;    
    cout << a.members.value << endl;
    return 0;
}

在c ++中它是否适用于未命名的结构继承？有没有这个用户的例子？

^{[1]免责声明:我不是假装提供的示例很有用.我很少使用未命名的结构,当我这样做时,它们通常将一些内置成员变量捆绑在一起,以便为类提供更清晰的接口.这个问题从观测上来memberspaces不需要nammed结构}

我正在实现可变的最小/最大函数.目标是利用编译时已知的参数数量并执行展开的评估(避免运行时循环).代码的当前状态如下(呈现min - max类似)

#include <iostream>  

using namespace std;

template<typename T>
T vmin(T val1, T val2)
{
    return val1 < val2 ? val1 : val2;
}

template<typename T, typename... Ts>
T vmin(T val1, T val2, Ts&&... vs)
{
    return val1 < val2 ?
        vmin(val1, std::forward<Ts>(vs)...) : 
            vmin(val2, std::forward<Ts>(vs)...);
}

int main()
{
    cout << vmin(3, 2, 1, 2, 5) << endl;    
    cout << vmin(3., 1.2, 1.3, 2., 5.2) << endl;
    return 0;
}

现在这可行,但我有一些问题/问题:

1. 该 …

我遇到了以下签名

double(&rotate_vec(double(&val)[4]))[4];

在评论中,它"声称" 接受并返回四个元素的数组.我的第一反应是,这甚至看起来不是标准的c ++,但是这个编译:

double(&rotate_vec(double(&val)[4]))[4]
{
    // ... 
    return val;
}

int main()
{
    double ar[4] = { 1, 2, 3, 5 };
    rotate_vec(ar);
    return 0;
}

1. 这个c ++怎么样？你会怎么看？
2. 我们不能从函数返回一个数组,只是指针,或者我们可以吗？