小编Nik*_*iou的帖子

是否有类似于Weka或其他实用程序中实现的MetaCost算法的scikit-learn方法/类来执行const敏感分析？

允许在c ++ 1y中编写自动返回类型的规则是什么？

#include <iostream>
using namespace std;

template<typename T1, typename T2>
auto f(T1 const& a, T2 const &b)
{
    if (a > b) return a-b;
    else return a+b;
}

int main() 
{
    cout << f(1, 2.) << endl;
    return 0;
}

函数体的圈复杂度是否存在限制？

介绍

• Ref限定符:一种消除隐含对象的rl-valuness的方法.作为一个简单的例子,请参加以下课程

  class example
  {
    int member;
  public:
    // ...
    int&       value() &;
    //                 ^
    int&&      value() &&;
    //                 ^^
    int const& value() const&;
    //                      ^
  };
  

  Run Code Online (Sandbox Code Playgroud)

  使用这个C++ 11特性(标^有的语法),允许我们控制value()将被调用的版本

  • 左值
  • 临时工
  • 常数值

  实际上,参考资格适用于classe *this

• 默认/删除函数:指定特殊成员函数,使其具有编译器生成(默认)定义或不可访问(删除).举个例子吧

  struct type {
    type(const type&)            = delete;
    type& operator=(const type&) = delete;
  };
  

  Run Code Online (Sandbox Code Playgroud)

  上面的结构实现了非可复制的非常清晰的语义

问题

• 结合这些功能是否可行/有效？
• 哪些是明确被禁止或不好的风格？
• 这种组合是否有任何用例/模式？(例如,快速简便地创建基于rl值的条件接口)

通过查看VS中的内存泄漏检测机制,我想到了这个问题.那里需要以下样板代码:

#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>

但用以下代码替换此代码DETECT_MLEAKS:

#define DETECT_MLEAKS\
#define _CRTDBG_MAP_ALLOC\
#include <stdlib.h>\
#include <crtdbg.h>\

无法做到.

有任何解决方法 - 建议？

如果我在两个无序容器中插入相同的(大小和值)元素,那么使用两个迭代器遍历容器总会在同一位置给出相同的元素吗？

如果是的话,可以使用(单个!)散列函数来打破这个决定论吗？

什么是技术/ c ++语言工具 - 提供编译时分支的功能？

第一次尝试枚举它们(我期待添加更正):

1. 重载分辨率:例如,选择"最佳"版本适合所提供的参数

   void F(X& arg);
   void F(X&& arg); 
   

   Run Code Online (Sandbox Code Playgroud)

2. 模板特化:创建为"特殊参数"运行的代码 - 一种对模板元编程和编译时递归至关重要的技术

   template<int N> struct A    { /* implementation */ };
   template<>      struct A<0> { /* specific  code */ };
   

   Run Code Online (Sandbox Code Playgroud)

3. SFINAE&expression sfinae:(1)的一个特例,为条件接口提供工具.

   template<class C, class F>
   auto test(C c, F f) -> decltype((c->*f)(), void()); // 'C' is pointer type
   

   Run Code Online (Sandbox Code Playgroud)

介绍

问题产生于对条件接口的需求.可能是因为我陷入了XY问题,但是(底线)我最终需要一个共享指针(基于运行时选择)管理或不管理(拥有或不拥有)资源.

到目前为止工作

以下是对非拥有共享指针的一些想法

1. 使用placement new,例如:

   struct MyStruct {}; 
   MyStruct ms1; 
   std::shared_ptr<MyStruct> sp(new(&ms1) MyStruct); 
   

   Run Code Online (Sandbox Code Playgroud)

2. 使用虚拟删除器

   std::shared_ptr<MyStruct> spn(new MyStruct, [](MyStruct*){}); 
   

   Run Code Online (Sandbox Code Playgroud)

题

• 有标准的提议方式吗？
• 是否存在"不做"规则？
• 至少有更好的方法吗？

笔记

我的类布局(将使用非拥有共享指针)如下所示:

template<typename T>
struct blah
{
    shared_ptr<T> _m;
};

现在,该_m成员可能拥有或可能不拥有基于运行时选择的资源.我没有使用的原因weak_ptr是因为_m实际上可能是一个拥有指针.

大多数C++程序员都知道空基类优化作为一种技术/习惯用法.空子课程会发生什么？例如

class EmptyBase {
    int i;
};

template<typename T>
class Derived : T { 
};

std::cout << sizeof(Derived<EmptyBase>); // Is there a standard verdic on this?

与EBO类似,应该有一个EDO声明由于派生类不提供任何更多成员,也没有将任何虚拟成员引入其参数化类型,因此它不需要更多内存.考虑到类似的东西可能会出现的各种情况(多重继承,单继承...):

• 这样的优化标准/可能吗？
• 如果是,这种优化的机制是什么,它们与EBO相似吗？

注意:使用从其参数化类型派生的类模板是非常典型的.主题是关于在这种情况下的空间浪费

典型的实现方式如下:

template <typename V, typename T>
struct Is_in_tuple;

template <typename V, typename T0, typename... T>
struct Is_in_tuple <V, tuple<T0, T...> >
{
  static const bool value = Is_in_tuple<V, tuple<T...> >::value;
};

template <typename V, typename... T>
struct Is_in_tuple <V, tuple<V, T...> >
{
  static const bool value = true;
};

template <typename V>
struct Is_in_tuple <V, tuple<> >
{
  static const bool value = false;
};

问题出现在VS2012中,其中存在元组,但可变参数模板不存在!

有没有一种解决方法,一种在没有可变参数模板的情况下执行此类测试的方法？

介绍

纯虚函数与常用语法相关:

virtual f() = 0; 

然而,从c ++ 11开始,有一种方法可以传达non existence(特殊)成员函数的显式:

Mystruct() = delete; // eg default constructor

Q

为什么这种语法不能扩展到纯虚函数以实现通信这种操作的一致性？:

virtual f() = delete; 

注意

我知道明显的答案是because the Standard says so!.我想知道这背后的原因以及是否有这样的建议(或意图).