例如,
#include <iostream>
int main() {
unsigned n{};
std::cin >> n;
std::cout << n << ' ' << (bool)std::cin << std::endl;
}
输入时-1,clang 6.0.0输出,0 0而gcc 7.2.0输出4294967295 1.我想知道谁是对的.或者两者都是正确的标准没有指定这个？如果失败,我认为(bool)std::cin被评估为假.clang 6.0.0也输入失败-0.
我发现的行为std::string::find与标准C ++容器不一致。
例如
std::map<int, int> myMap = {{1, 2}};
auto it = myMap.find(10); // it == myMap.end()
但是对于一串，
std::string myStr = "hello";
auto it = myStr.find('!'); // it == std::string::npos
为什么不应该失败的myStr.find('!')回报myStr.end()，而不是std::string::npos？
由于std::string与其他容器相比，它有些特殊，所以我想知道这背后是否有真正的原因。（令人惊讶的是，我找不到任何人在任何地方对此进行质疑）。
我不确定我是不理解还是文件没有明确制定.
以下摘录摘自最新草案(N3126,第29.6节):
bool atomic_compare_exchange_weak(volatile A* object, C * expected, C desired);
bool atomic_compare_exchange_weak(A* object, C * expected, C desired);
bool atomic_compare_exchange_strong(volatile A* object, C * expected, C desired);
bool atomic_compare_exchange_strong(A* object, C * expected, C desired);
bool atomic_compare_exchange_weak_explicit(volatile A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_weak_explicit(A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_strong_explicit(volatile A* object, C * expected, C desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_strong_explicit(A* object, C * expected, …为什么C++标准库流使用open()/ close()语义与对象生命周期分离？关闭破坏可能仍然在技术上使类RAII,但获取/释放独立性在范围中留下漏洞,其中句柄可以指向什么,但仍然需要运行时检查来捕获.
为什么图书馆设计师选择他们的方法而不是只在构造失败的构造函数中打开？
void foo() {
std::ofstream ofs;
ofs << "Can't do this!\n"; // XXX
ofs.open("foo.txt");
// Safe access requires explicit checking after open().
if (ofs) {
// Other calls still need checks but must be shielded by an initial one.
}
ofs.close();
ofs << "Whoops!\n"; // XXX
}
// This approach would seem better IMO:
void bar() {
std_raii::ofstream ofs("foo.txt"); // throw on failure and catch wherever
// do whatever, then close ofs on destruction ... …我想使用一个三元组类,尽可能与std :: pair类似.STL似乎没有.我不想使用太重的东西,比如Boost.是否有一些有用的FOSS非限制性许可三联类可以从某个地方解除？我应该自己动手吗？我应该完全做些什么吗？
编辑:关于std::tuple......
特定于三胞胎的课程真的没有益处吗？我的意思是,有了元组,我做不到
template<typename T1, typename T2, typename T3> std::tuple<T1, T2, T3> triple;
我可以吗？我不是必须键入dede个人类型组合三元组吗？
我有这个代码
#include <vector>
#include <iostream>
int main(int argc, char* argv[])
{
std::vector<int> v1,v2;
std::cout << std::distance(v1.begin(),v2.begin());
return 0;
}
它有一个bug,因为比较两个不同向量的迭代器没有意义.
我看了一下N3376在24.4.4迭代器操作在815页:
Run Code Online (Sandbox Code Playgroud)template<class InputIterator> typename iterator_traits<InputIterator>::difference_type distance(InputIterator first, InputIterator last);要求:如果
InputIterator符合随机访问迭代器的要求,last应可以从first或first到达last; 否则,last应该可以从first.
现在我认为需求没有实现.
在这种情况下,标准状态应该发生什么？
先来看看什么C++入门谈到unique_ptr和shared_ptr:
$ 16.1.6.效率和灵活性
我们可以确定
shared_ptr不将删除器作为直接成员,因为删除器的类型直到运行时才知道.因为删除器的类型是a
unique_ptr类型的一部分,所以删除器成员的类型在编译时是已知的.删除器可以直接存储在每个unique_ptr对象中.
所以似乎shared_ptr没有直接的删除成员,但unique_ptr确实如此.然而,另一个问题的最高投票回答说:
如果将deleter作为模板参数提供(如
unique_ptr),则它是类型的一部分,您不需要在此类型的对象中存储任何其他内容.如果将deleteter作为构造函数的参数传递(如shared_ptr),则需要将其存储在对象中.这是额外灵活性的代价,因为您可以为相同类型的对象使用不同的删除器.
引用的两段完全相互矛盾,让我感到困惑.更重要的是,许多人说unique_ptr是零开销,因为它不需要将删除器存储为成员.但是,正如我们所知,unique_ptr有一个构造函数unique_ptr<obj,del> p(new obj,fcn),这意味着我们可以将删除函数传递给它,因此unique_ptr似乎已将删除函数存储为成员.真是一团糟!
考虑以下代码：
#include <cctype>
#include <functional>
#include <iostream>
int main()
{
std::invoke(std::boolalpha, std::cout); // #1
using ctype_func = int(*)(int);
char c = std::invoke(static_cast<ctype_func>(std::tolower), 'A'); // #2
std::cout << c << "\n";
}
在此，对的两个调用std::invoke已标记为将来参考。预期的输出是：
a
在C ++ 20中可以保证预期的输出吗？
（注意：有两个函数tolower，一个称为in <cctype>，另一个称为in <locale>。引入了显式强制转换以选择所需的重载。）
c++ c++-standard-library language-lawyer unspecified-behavior c++20
我有一个sscanf解决的问题(从字符串中提取东西).我不喜欢sscanf,因为它不是类型安全的,而且是古老而可怕的.我想要聪明并使用C++标准库的一些更现代的部分.我应该用什么呢？
只是好奇为什么C++标准库使用小写和下划线代替camelCase或PascalCase命名约定.
就个人而言,我发现后者在输入代码时更容易处理,但有没有合理的理由使用前者？