为什么M(0)和N(0)有不同的结果？
#define CAT_I(a, b) a ## b
#define CAT(a, b) CAT_I(a, b)
#define M_0 CAT(x, y)
#define M_1 whatever_else
#define M(a) CAT(M_, a)
M(0); // expands to CAT(x, y)
#define N_0() CAT(x, y)
#define N_1() whatever_else
#define N(a) CAT(N_, a)()
N(0); // expands to xy
在C++中有没有办法声明一个函数没有副作用？考虑:
LOG("message").SetCategory(GetCategory());
现在假设发布版本中的LOG宏创建了一个NullLogEntry对象,该对象将SetCategory()定义为空函数.所以基本上整个表达式都可以(并且应该)被优化掉 - 从理论上说,GetCategory()调用可能会有一些副作用,所以我想编译器不允许抛弃它.
另一个示例可能是忽略其某些(或全部)参数的函数模板特化,但由于可能的副作用,编译器不允许在调用站点保存此类参数的评估.
我对吗？或者编译器能否最终优化此类调用？如果没有,有没有办法提示编译器这个函数没有副作用,所以如果忽略返回值那么可以跳过整个调用？
如果我foo()首先在基类中定义了虚函数B,然后在派生类中重写D,那么如何B::foo以指向成员函数的方式存储地址,以便在调用它时,调用将表现为一个有资格的id(如pd->B::foo())？
例:
struct B {
virtual int foo() { return 1; }
};
struct D: public B {
virtual int foo() { return 2; }
};
int main(int argc, char * argv[]) {
D* pd = new D();
int (B::*pf)() = &B::foo;
int r = (pd->*pf)();
return 0;
}
这会打电话D::foo().我可以初始化pf,即使动态类型是一个覆盖的类,它(pd->*pf)()也会调用吗？B::foo()pdfoo()
(在任何人问之前,我真的不想这样做,我只是好奇,如果可能的话.)
使用Objective-C++,我可以编写一个C++ IsObjectiveCClass<T>模板元函数,IsObjectiveCClass<T>::value当且仅当T是Objective-C类时才是真的吗？
从语言的C/C++子集的角度来看究竟是什么是ObjC类？在C/C++上下文中使用时,MyClass*指针似乎表现得像普通的C指针; 这是否意味着MyClass也是C类型？
我想专门std::iterator_traits<>为一个容器类模板的迭代器,它不具有通常的嵌套类型定义(如value_type,difference_type等),其源我不应该修改.基本上我想做这样的事情:
template <typename T> struct iterator_traits<typename Container<T>::iterator>
{
typedef T value_type;
// etc.
};
除了这不起作用,因为编译器无法推断T从Container<T>::iterator.
是否有任何工作方式来实现相同的目标？
例如:
template <typename T>
class SomeContainerFromAThirdPartyLib
{
typedef T ValueType; // not value_type!
// no difference_type
class iterator
{
typedef T ValueType; // not value_type!
// no difference_type
...
};
iterator begin() { ... }
iterator end() { ... }
...
};
现在假设我std::count()使用此类的实例调用.据我所知,在大多数STL实现中,count()返回iterator_traits<Iterator>::difference_type.iterator_traits<I>简单的主要模板typedef …
I have a Swift protocol MessageHandler with an associated type, a few different Message types, and also a class X:
protocol MessageHandler {
associatedtype Message
func handle(message: Message)
}
class FooMessage {}
class BarMessage {}
class X {}
Now how do I make X able to handle both FooMessages and BarMessages?
Trying this:
extension X: MessageHandler {
typealias Message = FooMessage
func handle(message: FooMessage) {}
}
extension X: MessageHandler {
typealias Message = BarMessage
func handle(message: BarMessage) {}
}
simply …
尝试使用Xcode 6.1中的clang版本(基于LLVM 3.5svn的clang-600.0.54)编译以下代码,-std=c++11并-stdlib=libc++给出一些我不太了解的错误.
#include <functional>
struct Impl
{
typedef std::function<void ()> L;
L l;
int i;
};
struct Hndl
{
Impl* impl;
Hndl(Impl* i): impl(i) {}
~Hndl() noexcept(false) {}
};
int main(int argc, char * argv[]) {
Hndl h(new Impl());
h.impl->l = [=]
{
h.impl->i = 42;
};
return 0;
}
结果:
In file included from t.cpp:1:
/Applications/Xcode-6.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/functional:1293:52: error: exception specification of overriding
function is more lax than base version
template<class _FD, class _Alloc, class _FB> …对于通用自由函数，我可以使用重载，从本质上将函数专门化为函数类型，如下所示：
func foo<T>(_ t: T.Type) { print("T is unknown") }
func foo<P>(_ t: ((P) -> Void).Type) { print("T is a function with one parameter") }
let f: (String) -> Void = { print($0) }
foo(type(of: f)) // prints "T is a function with one parameter"
注意第二个版本foo()是不受协议约束的，主要是因为据我所知，我们不能让函数类型符合协议（我们不能扩展非名义类型）。我可以创建一个OneParamFunction协议，并且可以在一个受约束的 中使用它foo()，但是我不能让所有的单参数函数类型都符合那个协议。
但是上述重载在没有协议约束的情况下工作。
对于泛型类的实例方法，这样的事情可能吗？
对我来说，这种语法似乎是最自然的，但它不受支持：
class Generic1<T> { init(_ t: T.Type) {} }
extension Generic1 { func foo() { print("T is unknown") } }
extension Generic1<P>
where …为什么以下代码在#2 处打印“BaseP”？
protocol BaseP { func foo() }
extension BaseP { func foo() { print("BaseP") } }
protocol SubP: BaseP {}
extension SubP { func foo() { print("SubP") } }
class C: SubP {}
let subP1: SubP = C()
subP1.foo() // #1 prints "SubP", fine.
class BaseC: BaseP {}
class SubC: BaseC, SubP {}
let subP2: SubP = SubC()
subP2.foo() // #2 prints "BaseP". why?
在这两种情况下，我们调用foo()静态类型为 的SubP引用，引用具有动态类型的对象，该对象是符合 的类SubP。即使它是静态调度，我认为它仍然应该调用SubP.foo(). 为什么在#2 处调用基本协议实现？
另外，为什么继承 from …
我喜欢的是一个构建配置,其中函数没有内联,除了一些选定的函数(可能会或可能不会内联,这取决于编译器).
更好的是某种"内联级别",我可以为每个函数指定这样的级别,加上构建时的最小级别,并且只允许内联最高级别的函数.我知道没有标准的解决方案,但编译器特定的黑客也同样受欢迎.
我希望能够在调试器中逐步完成我的大多数非内联函数,但是应该内联其中一些,部分是出于性能原因,部分是为了避免疯狂深度调用堆栈.代码涉及一些非常令人讨厌的模板元编程,但这部分大部分已完成,所以我想专注于其余部分.因此,将属于模板元程序的函数内联,而不是其他内联函数会很好.
有没有办法实现这样的事情？