小编Aru*_*run的帖子

我有一个这样的类模板:

template <typename T>
class MyClass
{
public:
     MyClass(const T & val);  // First
     MyClass(T&& val);        // Second
};

基本上我希望MyClass可以从一个Trvalue或一个左值来构造.现在,当我有类似的东西

const A& foo = ...;
MyClass<const A&> x(foo); 

我得到重新定义错误MyClass(const A & val).

我认为这是因为T &&是一个通用引用,并且由于引用了折叠规则,第二个构造函数也被转换为具有与第一个相同的签名.

首先是我对错误场景的理解是否正确？其次,我如何解决这个问题(我希望能够使用构造MyClass时移动语义提供的优化)？

考虑以下我试图启动 10000 个线程的两个代码片段：

片段 1

    std::array<std::future<void>, 10000> furArr_;
    try
    {
        size_t index = 0;
        for (auto & fut : furArr_)
        {
            std::cout << "Created thread # " << index++ << std::endl;
            fut = std::async(std::launch::async, fun);
        }
    }
    catch (std::system_error & ex)
    {
        std::string str = ex.what();
        std::cout << "Caught : " << str.c_str() << std::endl;
    }
    // I will call get afterwards, still 10000 threads should be active by now assuming "fun" is time consuming

片段 2

    std::array<std::thread, 10000> threadArr; …

在我使用以下代码片段的实验中,我没有找到任何特别的区别,无论我是否使用ios创建流:二进制模式:

int main()
{
    ifstream ostr("Main.cpp", ios::in | ios::binary | ios::ate);
    if (ostr.is_open())
    {
        int size = ostr.tellg();
        char * memBlock = new char[size + 1];
        ostr.seekg(0, ios::beg);
        ostr.read(memBlock, size);
        memBlock[size] = '\0';
        ofstream file("trip.cpp", ios::out | ios::binary);
        file.write(memBlock, size);
        ostr.close();
    }
}

在这里,我试图将原始源文件复制到另一个具有不同名称的文件中.

我的问题是当使用/不使用ios :: binary模式打开fstream对象时,读/写调用(与二进制文件IO相关)之间的区别是什么？使用二进制模式有什么好处吗？什么时候何时何时不使用它来做文件IO？

是否可以执行以下操作：

template <unsigned majorVer, unsigned minorVer>
class Object
{
public:

    if constexpr ((majorVer == 1) && (minorVer > 10))
        bool newField;
    else
        int newInt
};

或者

template <unsigned majorVer, unsigned minorVer>
class Object
{
public:

    if constexpr ((majorVer == 1) && (minorVer > 10))
        bool newField;
    // Nothing other wise
};

使用 C++17？我想根据一些可以在编译时检查的条件来更改类的结构。有没有办法实现这一目标？

据我所知,默认情况下,C++支持的所有流IO都是缓冲的.

这意味着要输出的数据被放入缓冲区直到它已满,然后被发送到输出设备,类似于输入,一旦缓冲区为空,就会读取数据...所有这一切都是为了使数量昂贵的系统电话可以最小化.

但是如何验证这种行为.我的意思是考虑以下代码

int main()
{
    cout << "Hello world\n";
    return 0
}

缓冲在哪里成像？我知道有缓冲发生,但如何解释呢？屏幕上会立即看到输出,那么实际看到缓冲I/O的代码示例是什么呢？

以下是我的插入排序代码:

void InsertionSort(vector<int> & ioList)
{
  int n = ioList.size();
  for (int i = 1 ; i < n ; ++i)
  {
    for (int j = 0 ; j <= i ; ++j)
    {
      //Shift elements if needed(insert at correct loc)
      if (ioList[j] > ioList[i]) 
      {
        int temp = ioList[j];
        ioList[j] = ioList[i];
        ioList[i] = temp;
      }
    }
  }
}

算法的平均复杂度为O(n ^ 2).

根据我对大O符号的理解,这是因为在这种情况下我们运行两个循环(外部一个n-1次,内部一个1,2,... n-1 = n(n-1)/ 2次因此由此产生的算法的无症状复杂性为O(n ^ 2).

现在我已经读过,输入数组已经排序的情况就是最好的情况.在这种情况下,算法的大O复杂度是O(n).但是我无法理解这是如何可能的,因为在两种情况下(平均情况和最佳情况)我们必须运行相同次数的循环并且必须比较元素.唯一可以避免的是元素的转移.

那么复杂性计算也涉及这种交换操作的一个组成部分？

在以下代码段中:

std::vector<std::unique_ptr<int>> vec;
vec.emplace_back(std::make_unique<int>(1));
vec.emplace_back(std::make_unique<int>(2));
vec.emplace_back(std::make_unique<int>(3));
vec.emplace_back(std::make_unique<int>(4));
vec.emplace_back(std::make_unique<int>(5));
auto & itr = std::find_if(vec.begin(), vec.end(), [](std::unique_ptr<int> & val)->bool
{
   return *val == 5;
});
vec.erase(itr);

我收到以下警告:

Severity    Code    Description Project File    Line
Warning C4239   nonstandard extension used: 'initializing': conversion from 'std::_Vector_iterator<std::_Vector_val<std::_Simple_types<std::unique_ptr<int,std::default_delete<_Ty>>>>>' to 'std::_Vector_iterator<std::_Vector_val<std::_Simple_types<std::unique_ptr<int,std::default_delete<_Ty>>>>> &'

我究竟做错了什么？

我在VS2015上,这个警告只在警告级别4出现.我应该忽略它还是会导致任何偷偷摸摸的问题(如果unique_ptr在更大的上下文中使用了涉及s 矢量的类似代码)？

我有一个类A,它在构造函数中为一个整数(由类memeber指出_pPtrMem指向)动态分配内存,并在析构函数中释放相同的内容.为了避免Shallow复制,我重载了赋值运算符和复制构造函数.赋值运算符重载的广泛使用方式如下:

A& operator = (const A & iToAssign)
{
  if (this == & iToAssign)  // Check for self assignment
    return *this;
  int * pTemp = new int(*(iToAssign._pPtrMem)); // Allocate new memory with same value
  if (pTemp)
  {
    delete _pPtrMem;  // Delete the old memory
    _pPtrMem = pTemp; // Assign the newly allocated memory
  }
  return *this;   // Return the reference to object for chaining(a = b = c)
}

实现相同的另一种方法可能是

A& operator = (const A & iToAssign)
{
  *_pPtrMem= *(iToAssign._pPtrMem); …

我有一个类,它在容器内部保存指针,如下所示:

class A
{
public:

    A(int x) : _data(x){}

    A ** begin()
    {
        return v.empty() ? nullptr : &v[0];
    }

    A ** end()
    {
        return v.empty() ? nullptr : &v[0] + v.size();
    }

    void Display()
    {
        cout << "Data = " << _data << endl;
    }

    vector<A *> v;

private:

    int _data;
};

现在我希望能够在A的对象上使用基于范围的循环,因此具有相同的成员开头和结尾.它按预期工作.但是如果我因为这里提到的原因尝试用双端队列替换向量,它会在尝试访问最后一个元素时崩溃.如果我实现end()的方式不正确,有人可以提供正确的吗？

请考虑以下代码段:

#include <chrono>
#include <cassert>

int main()
{
     auto result1 = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::high_resolution_clock::now().time_since_epoch());
     auto result2 = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch());
     assert((result2.count() - result1.count()) < 10);
}

我期待两个值之间的计数差异应该是最小的(理想情况下小于一秒).但是对于VS2015,计数的差异大约为数十亿秒.这怎么可能？