考虑：
template <typename T>
class Base
{
public:
static const bool ZEROFILL = true;
static const bool NO_ZEROFILL = false;
}
template <typename T>
class Derived : public Base<T>
{
public:
Derived( bool initZero = NO_ZEROFILL ); // NO_ZEROFILL is not visible
~Derived();
}
我无法使用GCC g ++ 3.4.4（cygwin）进行编译。
在将它们转换为类模板之前，它们是非泛型的，派生类能够查看基类的静态成员。 C ++规范的要求中是否存在这种可见性损失，还是我需要采用语法更改？
我了解到Base<T>的每个实例都将具有其自己的静态成员“ ZEROFILL”和“ NO_ZEROFILL”，即Base<float>::ZEROFILL和Base<double>::ZEROFILL是不同的变量，但我并不在乎； 该常量用于代码的可读性。 我想使用静态常量，因为就名称冲突而言，这比使用宏或全局方法更安全。
我想确保RAII类始终分配在堆栈上。
如何防止通过“新”运算符分配类？
C ++程序员应该知道哪些C ++习惯用法？
用C ++习惯用语，是指仅适用于C ++或比大多数其他语言更适用于C ++的设计模式或做某些事情的方式。
为什么要使用成语？成语有什么作用？
stdio.h或cstdio中包含什么？ 为什么？是否可以防止对象的堆栈分配，而只允许在堆上使用“ new”来初始化它？
编译器为一个类创建的所有成员函数是什么？ 这是否一直发生？ 像破坏者一样。我担心的是是否为所有类创建了它，为什么需要默认构造函数？
在C ++中，我想不出要从A继承private / protected的情况。基类：
class Base;
class Derived1 : private Base;
class Derived2 : protected Base;
真的有用吗？
如果我有一个C ++ 11程序运行两个线程，并且其中一个抛出未处理的异常，会发生什么？ 整个程序会火死吗？ 引发异常的线程是否会单独死亡（如果是，在这种情况下我可以获取异常）吗？ 还有其他东西吗？
在C ++中确切地销毁对象是什么意思？ 因为没有垃圾收集器，我是否必须手动销毁它们？ 异常如何发挥作用？
（注意：这是Stack Overflow的C ++ FAQ的一个条目。如果您想批评以这种形式提供FAQ的想法，则可以在开始所有这些操作的meta上进行发布。） 该问题在C ++聊天室中进行监控，C ++聊天室首先出现了FAQ想法，因此，提出这个想法的人很可能会读懂您的答案。）
如标题所示，
“假设”规则到底是什么？
一个典型的答案是：
允许任何和所有代码转换而不会改变程序可观察行为的规则
我们会不时地从某些实现中获取归因于该规则的行为。 很多次是错误的。 所以，这到底是什么规则。 该标准没有清楚地将此规则作为一个部分或段落提及，那么该规则的作用范围到底是什么呢？ 对我来说，这似乎是一个灰色区域，该标准未对其进行详细定义。 有人可以引用标准的参考文献来详细说明细节吗？
注意：将其标记为C和C ++，因为它与两种语言都相关。
左和右移位运算符（<<和>>）已经在C ++中可用。但是，我找不到如何执行循环移位或旋转操作的方法。
如何执行“向左旋转”和“向右旋转”之类的操作？
在这里向右旋转两次
Initial --> 1000 0011 0100 0010
应导致：
Final --> 1010 0000 1101 0000
一个例子会有所帮助。
（编者注：如果C的旋转计数为零，或者编译为多个旋转机械指令，则许多用C表示旋转的常见方法都会遭受不确定的行为。此问题的答案应记录最佳实践。）
我很难看到函数指针的实用程序。 我想它在某些情况下可能是有用的（毕竟它们存在），但我想不出使用函数指针更好或不可避免的情况。
你能举出一些好用函数指针的例子（在C或C ++中）吗？
我有一个具有相同名称的函数，但在基类和派生类中具有不同的签名。 当我尝试在继承自派生的另一个类中使用基类的函数时，我收到一个错误。 请参阅以下代码：
class A
{
public:
void foo(string s){};
};
class B : public A
{
public:
int foo(int i){};
};
class C : public B
{
public:
void bar()
{
string s;
foo(s);
}
};
我从gcc编译器收到以下错误：
In member function `void C::bar()': no matching function for call to `C::foo(std::string&)' candidates are: int B::foo(int)
如果我从类B中删除int foo(int i){};，或者如果我从foo1重命名它，一切正常。
这有什么问题？
C ++中的括号用于许多地方：例如 在函数调用和分组表达式中覆盖运算符优先级。 除了非法的额外括号（例如函数调用参数列表周围）之外，C ++的一般但非绝对规则是额外的括号永远不会受到伤害：
5.1主要表达式[expr.prim]
5.1.1一般[expr.prim.general]
6带括号的表达式是一个主要表达式，其类型和 值与所附表达式的值相同。 存在 括号不会影响表达式是否为左值。 带括号的表达式可以在完全相同的上下文中使用 可以使用封闭表达式的那些，并使用相同的表达式 意义，除非另有说明。
问题：在哪些上下文中，额外的括号会改变C ++程序的含义，而不是覆盖基本的运算符优先级？
注意：我认为指针到成员语法的限制为&qualified-id而没有括号超出范围，因为它限制语法而不是允许两个具有不同含义的语法。 同样，在预处理程序宏定义中使用括号也可以防止不必要的运算符优先级。
我已经开始为我的编程课学习C ++了。 我已经下载了这个“Hello World”程序：
#include <iostream>
using namespace std;
int main()
{
cout << "Hello, World!";
return 0;
}
但是Turbo C ++抱怨道：
Error D:\HELLO.CPP 1: Unable to open include file 'IOSTREAM'
Error D:\HELLO.CPP 2: Declaration syntax error
Error D:\HELLO.CPP 6: Undefined symbol 'cout'
这个非常简单的程序出了什么问题？ 我该如何纠正这些错误？
在C ++ 14中，关联容器似乎已经从C ++ 11改变了 - [associative.reqmts] / 13说：
除非存在类型
Compare::is_transparent，否则成员函数模板std::set,Key, Compare = std::less<Key>, ...,find,count和equal_range不应参与重载决策。
使比较器“透明”的目的是什么？
C ++ 14还提供了这样的库模板：
template <class T = void> struct less {
constexpr bool operator()(const T& x, const T& y) const;
typedef T first_argument_type;
typedef T second_argument_type;
typedef bool result_type;
};
template <> struct less<void> {
template <class T, class U> auto operator()(T&& t, U&& u) const
-> decltype(std::forward<T>(t) < std::forward<U>(u));
typedef *unspecified* is_transparent;
};
例如，std::set没有透明比较器，但Key, Compare = std::less<Key>, ...会有一个。
这解决了什么问题，这会改变标准容器的工作方式吗？ 例如，模板参数std::set仍然是Key, Compare = std::less<Key>, ...，那么默认设置是否会丢失其find，count等成员？
注意：这不是关于如何使用内联函数或它们如何工作的问题，更多的是为什么它们按照它们的方式完成。
类成员函数的声明不需要将函数定义为inline，它只是函数的实际实现。 例如，在头文件中：
struct foo{
void bar(); // no need to define this as inline
}
那么为什么类函数的内联实现必须在头文件中呢？ 为什么我不能把内联函数放到.cpp文件中？ 如果我在哪里尝试将内联定义放在.cpp文件中，我会得到一个错误：
error LNK2019: unresolved external symbol
"public: void __thiscall foo::bar(void)"
(?bar@foo@@QAEXXZ) referenced in function _main
1>C:\Users\Me\Documents\Visual Studio 2012\Projects\inline\Debug\inline.exe
: fatal error LNK1120: 1 unresolved externals
最近在一次采访中有一个以下客观类型的问题。
int a = 0;
cout << a++ << a;
回答：
一个。10
湾01
C。 未定义的行为
我回答了选择b，即输出为“01”。
但令我惊讶的是，一位采访者告诉我，正确的答案是选项c：undefined。
现在，我确实知道C ++中序列点的概念。 以下语句的行为未定义：
int i = 0;
i += i++ + i++;
但根据我对声明cout << a++ << a的理解，ostream.operator<<()将被调用两次，首先是ostream.operator<<(a++)，后来是ostream.operator<<(a)。
我还检查了VS2010编译器的结果，其输出也是'01'。
以下代码适用于Visual Studio 2008，有无优化。 但它只适用于没有优化的G ++（O0）。
#include <cstdlib>
#include <iostream>
#include <cmath>
double round(double v, double digit)
{
double pow = std::pow(10.0, digit);
double t = v * pow;
//std::cout << "t:" << t << std::endl;
double r = std::floor(t + 0.5);
//std::cout << "r:" << r << std::endl;
return r / pow;
}
int main(int argc, char *argv[])
{
std::cout << round(4.45, 1) << std::endl;
std::cout << round(4.55, 1) << std::endl;
}
输出应该是：
4.5
4.6
但g ++优化（O1 - O3）将输出：
4.5
4.5
如果我在t之前添加/fp:fast关键字，它可以工作，那么可能存在某种优化错误吗？
测试g ++ 4.1.2和4.4.4。
以下是ideone的结果：[http://ideone.com/Rz937]
我在g ++上测试的选项很简单：
g++ -O2 round.cpp
更有趣的结果，即使我在Visual Studio 2008上打开/fp:fast选项，结果仍然是正确的。
进一步问题：
我想知道，我应该总是打开/fp:fast选项吗？
因为我测试的g ++版本附带了CentOS / Red Hat Linux 5和CentOS / Redhat 6。
我在这些平台下编译了很多程序，我担心它会在我的程序中引起意外的错误。 调查我的所有C ++代码并使用库是否有这样的问题似乎有点困难。 有什么建议吗？
是否有人对为什么连打开/fp:fast感兴趣，Visual Studio 2008仍然有效？ 看起来Visual Studio 2008在这个问题上比g ++更可靠吗？
在排序甚至分配期间，许多标准容器（例如std::list和std::vector）使用std::swap()。
但是std::swap()的std实现非常普遍，而且对于自定义类型来说效率很低。
因此，通过使用自定义类型特定实现重载std::swap()可以获得效率。 但是如何实现它以便std容器使用它？