小编uj2*_*uj2的帖子

考虑以下代码:

#define F(x, ...) X = x and VA_ARGS = __VA_ARGS__
#define G(...) F(__VA_ARGS__)
F(1, 2, 3)
G(1, 2, 3)

X = 1 and VA_ARGS = 2, 3两个宏的预期输出,这就是我用GCC得到的,但是,MSVC将其扩展为:

X = 1 and VA_ARGS = 2, 3
X = 1, 2, 3 and VA_ARGS =

也就是说,__VA_ARGS__将其扩展为单个参数,而不是分解为多个参数.

有什么方法吗？

说我有一个功能:

void someFunc(int *x,int count);

这是我无法控制的,所以我不能写它来接受迭代器.

这样调用它是否安全(无论具体的STL实现如何):

vector<int> v;
/* ... */
someFunc(&v[0],v.size());

显然,一个反例就是vector<bool>.其他类型怎么样？(假设我没有vector以任何方式专门化).

有机会使用enable_if类型转换运算符吗？看起来很棘手,因为返回类型和参数列表都是隐式的.

GCC是否有等效的编译器切换到VC的浮点模型开关(/fp)？

特别是,我的应用程序受益于编译/fp:fast和精度并不是什么大问题,我应该如何使用GCC编译它？

VC++ 2010中的C++ 0x模式是否有关闭开关？我正在开发一个应该在非0x编译器上编译的项目,因此我想针对当前标准进行编译.(即使没有直接使用新功能,仍然存在微妙之处,使得C++ 0x更加谨慎).

我找到的最接近的开关是,Configuration Properties -> C/C++ -> Language -> Disable Language Extensions但不是这样.

考虑这个宏:

#define MAKE_TEMPLATE(...) template <typename T, __VA_ARGS__ >

当使用零参数时,它会产生错误代码,因为编译器需要逗号后面的标识符.实际上,VC的预处理器足够聪明,可以删除逗号,但GCC不是.由于宏不能重载,看起来这个特殊情况需要一个单独的宏才能正确,如:

#define MAKE_TEMPLATE_Z() template <typename T>

有没有办法让它工作而不引入第二个宏？

这段代码:

template <template <typename> class T>
class A
{
};

template <typename T>
class B
{
    A<B> x;
};

不编译,我想自从A<B>被解释为A<B<T> >在B范围内.

那么,你如何B在其范围内作为模板模板参数传递？

我正在寻找一种快速执行以下分区的方法:

• Dividend是一个带符号的64位整数.
• 除数是带符号的32位整数.
• 商数应该是带符号的64位整数,余数是不必要的.
• 股息的低位为零.

我只使用32位数据类型,因为编译器不支持64位数据类型,也没有汇编.准确度可能会有所偏差,有利于速度.

关于这个的任何指针？

考虑以下代码:

template <int N>
struct X
{
 friend void f(X *) {}
};

int main()
{
 f((X<0> *)0); // Error?
}

编译器似乎非常不同意.(MSVC08/10表示否,GCC <4.5表示是,但4.5表示否,sun 5.1表示是,intel 11.1表示也是,但是comeau说不(两者都是EDG)).

根据"C++模板 - 完整指南":

...假设一个涉及查找关联类中的朋友的调用实际上导致该类被实例化......虽然这是C++标准编写人员的明确意图,但标准中没有明确规定.

我找不到标准中的相关部分.任何参考？

考虑这种变化:

template <int N>
struct X
{
 template <int M>
 friend void f(X<M> *) {}
};

template <>
struct X<0>
{
};

int main()
{
 X<1>();
 f((X<0> *)0); // Error?
}

这里的关键问题是注入的可行功能是否X<1>应该在ADL期间可见X<0>？它们是否相关？上面提到的所有编译器都接受此代码,但Comeau仅在宽松模式下接受它.不确定标准对此有何看法.

你对此有何看法？

考虑这样一种情况:函数模板需要转发参数,同时保持它的左值,以防它是非const左值,但它本身与参数实际上是无关的,如:

template <typename T>
void target(T&) {
    cout << "non-const lvalue";
}

template <typename T>
void target(const T&) {
    cout << "const lvalue or rvalue";
}


template <typename T>
void forward(T& x) {
    target(x);
}

何时x是rvalue,而不是T推导为常量类型,它会给出错误:

int x = 0;
const int y = 0;

forward(x); // T = int
forward(y); // T = const int
forward(0); // Hopefully, T = const int, but actually an error
forward<const int>(0); // Works, T = const int

似乎对于 …