小编Kap*_*pil的帖子

正如我们所知，当新元素添加到 std::vector （通过 Push_back）时，\xe2\x80\x99s 可能缺少空间，对于这些情况，向量会分配更大的内存块来保存其所有元素，然后从现有块到新块。在 C++98 中，这是通过从旧位置复制元素然后销毁这些对象来完成的，因此它可以提供强大的异常保证，而在 C++11 中，可以使用移动构造函数对其进行优化是 no except 但如果我的析构函数是 no except(false) 会发生什么那么为什么优化没有发生？

#include <iostream>\n#include <vector>\n\nclass X\n{\npublic:\n    X()\n    {\n    }\n    X(const X& ob) noexcept\n    {\n      std::cout<<"Copy Constructor...."<<std::endl;\n    }\n    X(X&& ob) noexcept\n    {\n       std::cout<<"Move Constructor...."<<std::endl;\n    }\n    ~X() noexcept(false)\n    {\n    }\n};\nint main()\n{\n   std::vector<X> myobs;\n   for(int i=0;i<1000;i++)\n   {\n      myobs.push_back(X());\n   }\n   return 0;\n}\n

为什么在上面的场景中调用复制构造函数，还要注意，如果我将析构函数设置为 noexcept （默认行为），那么只会调用移动构造函数。

添加我对强异常保证（在向量::push_back中）的理解是，在成功复制所有元素之前，旧内存中的任何元素都不会被销毁，这意味着析构函数在最后被调用，因此它们是否为 noexcept 并不重要或不

在下面的代码片段中，我使用了可变参数模板 findSum 函数，并确保该函数的参数类型使用概念相同，但有人可以建议我如何确保该函数的返回类型也与参数类型匹配。

#include <iostream>
#include <concepts>
template<typename F,typename... R>
struct FirstVariadicType
{
    using Type = F;
};

template<typename... Ts>
requires requires(Ts... args){
std::conjunction_v<std::is_same<typename FirstVariadicType<Ts...>::Type, Ts>...>;
}
auto findSum(Ts... args)
{
     return (... + args);
}
int main()
{
    std::cout<<"sum of 2 and 3 is "<<findSum(2,3)<<std::endl;
    return 0;
}

我正在阅读二进制信号量和互斥量之间的差异（二进制信号量和互斥量之间的差异），我想验证的一件事是，当任务锁定（获取）互斥量时，它只能解锁（释放）它。如果另一个任务试图解锁一个尚未锁定的互斥锁（因此不拥有该互斥锁），则会遇到错误情况，最重要的是，互斥锁未解锁，为此我在c ++ 14的代码下面创建了该互斥锁：

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
using namespace std;

int counter;
int i;
std::mutex g_pages_mutex;
void increment()
{
    std::cout<<"increment...."<<std::endl;    
    g_pages_mutex.lock();
    bool flag = g_pages_mutex.try_lock();
    std::cout<<"increment Return value is "<<flag<<std::endl;
    counter++;
    std::this_thread::sleep_for(5s);
}
void increment1()
{
    std::this_thread::sleep_for(5s);    
    std::cout<<"increment1...."<<std::endl;       
    g_pages_mutex.unlock();    
    counter++;
    bool flag = g_pages_mutex.try_lock();
    std::cout<<"increment1 Return value is "<<flag<<std::endl;
}
int main()
{
    counter = 0;
    std::thread t(increment);
    std::thread t1(increment1);
    t.join();
    t1.join();
    return 0;
}

但是，在此示例中，我能够从不拥有该线程的线程中解锁互斥锁，因此只希望有一些理解上的差距，还是在c ++ 14 std :: mutex中存在此问题？

我无法理解为什么下面的代码没有排序向量的前两个元素:

int main() {
    std::vector<int> v = {2,1,3,1,2};
    std::sort(v.begin(),v.begin()+1);
    for(auto elem:v)
    {
      std::cout<<elem<<std::endl;
    }
    // your code goes here
    return 0;
}

有什么想法吗 ？

我有模板化的xml,如下所示,我需要找到最后一个ChildTag xml字符串.

<?xml version="1.0" encoding="UTF-8">
<Test xmlns:Test="http://www.w3.org/TR/html4/">
<TestID>1</TestID>
<TestData>
<ParentTag1>A</ParentTag1>
<ParentTag2>B</ParentTag2>
{{ChildTag}}
</TestData>
</Test>
ChildTag
<Tag1>E</Tag1>
<Tag2>F</Tag2>

所以我遵循的方法是在该字符串中找到最后一个ChildTag并从该位置获取子串.下面是这个的示例代码,应该注意我正在从文件中读取这个xml:

#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>
using namespace std;
int main()
{
    std::ifstream fin("abc.xml");
    fin.unsetf(ios_base::skipws);
    std::string fileData = std::string(std::istream_iterator<char>(fin),std::istream_iterator<char>());
    std::cout<<fileData<<std::endl;
    auto childxmlindex = fileData.find_last_of("ChildTag");
    std::cout<<childxmlindex<<std::endl;
    std::cout<<"Child XML : "<<fileData.substr(childxmlindex)<<std::endl;
    return 0;
}

问题是使用行fileData.find_last_of("ChildTag"),因为它给出了与实际索引无关的随机数.这个字符串是否有任何问题导致find_last_of失败？