定义<运算符后，您就可以估计其余关系运算符的行为方式。我正在尝试为我的课程实现一种方法。
我想要的是仅定义<和其余的运算符隐式默认。到目前为止我所得到的是这个设计，我将在下面进一步详细说明：
template<typename T>
struct relational
{
friend bool operator> (T const &lhs, T const &rhs) { return rhs < lhs; }
friend bool operator==(T const &lhs, T const &rhs) { return !(lhs < rhs || lhs > rhs); }
friend bool operator!=(T const &lhs, T const &rhs) { return !(rhs == lhs); }
friend bool operator<=(T const &lhs, T const &rhs) { return !(rhs < lhs); }
friend bool operator>=(T const &lhs, T const &rhs) …我想得到一个对象的价值(标题是这样的扰流板).
该对象可以是指针或不是.我正在寻找一个STL函数,它将成为"反转对应物"std::decay
到目前为止我看到的是这样的:
template<typename T>
typename std::enable_if<std::is_pointer<T>::value,
typename std::add_reference<typename std::remove_pointer<T>::type>::type>::type
deref(T val)
{ return *val; } // lets call it the * policy
template<typename T>
typename std::enable_if<!std::is_pointer<T>::value,
typename std::add_reference<T>::type>::type
deref(T& val)
{ return val; } // lets call it the plain policy
当然,这些是在类模板中使用的,其中T是一个参数.我故意避免使用decltype和朋友在C++ 03中实现可实现的东西:(
有更好,更明智的方式吗？这个解决方案会"缩放"到C++ 11 &&吗？
以下代码位于.h文件中(包含保护)
template<typename T1, typename T2> // a
void func(T1 const &t1, T2 const &t2)
{
std::cout << "\nbase template";
}
template<> // b
inline void func<int, int>(int const &t1, int const &t2)
{
std::cout << "\nspecialization for integers";
}
从(b)中删除inline关键字时,以下代码(从包含.h的.cpp调用)将无法编译
func<int, int>(1, 2);
发出链接器错误"错误LNK2005:"void __cdecl func(int const&,int const&)"(?? $ func @HH @@ YAXABH0 @ Z)已在ConsoleApplication1.obj中定义"
为什么会这样？
编辑:
因为它们是定义(由Luchian Grigore回答),显式特化是否意味着显式实例化或者这个编译器是否具体？
有人可以发现以下程序的问题是什么,它不会像预期的那样打印数组的数字
#include<stdio.h>
#define TOTAL_ELEMENTS (sizeof(array) / sizeof(array[0]))
int array[] = {23,34,12,17,204,99,16};
int main()
{
int d;
for(d=-1;d <= (TOTAL_ELEMENTS-2);d++)
printf("%d\n",array[d+1]);
return 0;
}
虽然最初似乎工作,当通过制造商函数调用(具有模板参数推导)时,存在两个重载,T const&一个带有T&& 中断和一个带有中断编译:
#include <iostream>
#include <utility>
#include <functional>
using namespace std;
// -----------------------------------------------
template<typename T, typename F>
struct Test
{
T m_resource;
F m_deleter;
Test(T&& resource, F&& deleter)
: m_resource(move(resource)), m_deleter(move(deleter))
{
}
Test(T const& resource, F const& deleter)
: m_resource(resource), m_deleter(deleter)
{
}
};
// -----------------------------------------------
// -----------------------------------------------
template<typename T, typename F>
Test<T, F> test(T&& t, F&& f)
{
return Test<T, F>(move(t), move(f));
}
template<typename T, typename F>
Test<T, F> …有关于使用和理性的帖子和文章std::uncaught_exception.
该功能提供的功能归结为
std :: uncaught_exception检测堆栈展开当前是否正在进行中.
在搜索其定义时,我看到的是对DLL的调用
_CRTIMP2_PURE bool __CLRCALL_PURE_OR_CDECL uncaught_exception();
如何实现程序中的这种内省水平？这是仅仅通过c ++或编译器/汇编魔法实现的东西必须发挥作用吗？
有三种方法（我知道）来初始化指向空值的指针：
T a = T(); // T is a pointer type
T a{}; // brace initializers don't suffer from the most vexing parse
即使 atypedef是必需的，这种形式也可以在非通用代码中得到满足，例如
typedef int* ip;
int *p = ip();
nullptr手动设置int *p = nullptr;
int *p = NULL;
每种方法的优缺点是什么？
是否存在每种方法都被认为是最合适的用例？
如何确定对象的运行时大小？
我们不是在谈论类型的大小，而是在执行过程中可能发生变化的对象的实际大小，例如：
vector<int> v;
auto a = MagicSizeF(v); // magic size function
v.push_back(2);
v.push_back(2);
// this should hold - ok there's small consainer optimizations and initial
// vector capacity and implementation details, but you get what I mean
assert(MagicSizeF(v) > a);
在向量的情况下，它可以这样实现：
template<typename T>
auto MagicSizeF(vector<T> const& v) {
return v.size()*sizeof(T); // or v.capacity() to be strict
// other implementation details memory consumers could be added
}
但是对于任意类型的对象，是否有标准/通用方法来执行此操作？是否需要 ABI 来绕过所有实现细节？
标题中描述的命令是否可逆？
我尝试搜索日志(使用hg日志)并剥离相应的变更集,但没有为此命令发出日志.
我想要一种机制来在编译时确定迭代器是否是反向的.
迭代器特性只能帮助迭代器类型的类别,我需要的是以下几行:
template<typename IterType>
struct IsReverseIterator
{
enum { Yes = /* Implementation of the mechanism */ };
}
我有一个解决方案,虽然有一个小缺点,但也必须提供容器类型:
typedef char TrueT;
typedef struct { TrueT _[2]; } FalseT;
template<typename Cont> TrueT IsReverseIterator(typename Cont::const_reverse_iterator);
template<typename Cont> FalseT IsReverseIterator(...);
它明显使用SFINAE,可以这样使用:
std::vector<int> v;
std::cout << (sizeof(IsReverseIterator<std::vector<int>>(v.begin())) == sizeof(TrueT)) << std::endl;
std::cout << (sizeof(IsReverseIterator<std::vector<int>>(v.rbegin())) == sizeof(TrueT)) << std::endl;
有任何想法吗？
编辑
要解释我正在搜索的内容,请参考以下代码
template<typename Cont, typename It>
bool points_to_last_element(Cont const &container, It iter)
{
return iter == container.rend(); …宏通常用于文本替换。就我而言，我需要有条件地清除一些关键字，以便在没有特定功能的编译器中进行编译。
具体来说，我一直在研究这个片段来自的cpp11 范围
template <typename C>
struct has_size {
template <typename T>
static constexpr auto check(T*) -> // problem in VS2013
typename std::is_integral<
decltype(std::declval<T const>().size())>::type;
// .. some more stuff
};
我提供这个作为产生问题的例子。在上面的代码中，我最终做了
template <typename T>
static
#if COMPILE_WITH_GCC_NEW_ENOUGH
constexpr
#endif
auto check(T*) ->
因为还有其他部分constexpr需要替换const才能编译。
我要问的是一种说法，例如
#define Constexpr ?????????
这样它就会constexpr在 gcc 编译中被替换，而在 VS 编译中没有文本内容。
我正在查看该range功能,在线搜索显示(编辑:在2.x),它是热切评估
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
但是当我在我的本地Python3.3解释器中尝试下面的代码时
a = range(10)
print(a)
我得到一个输出
range(0, 10)
这是我对懒惰评估函数的期望,是什么情况？
注意:在Python2.7中,它始终表现为热切评估.
我正在建立一个系统,我必须多次调用一些命令,具体取决于用户输入,例如
void handle(int MouseInput)
{
switch(MouseInput)
{
case Move:
ActionMove->execute();
// ...
case BtnUp:
ActionBtnUp->execute();
// ...
}
}
然而,由于系统是可参数化的,我并不总是拥有例如actionMove命令对象(有时我在Move上什么都不做).
什么更快:
实现空对象模式,即具有具有execute如此功能的对象
execute() {}
或者每次都检查空指针:
if (ActionBtnUp) ActionBtnUp->execute();
我要问的是什么是更大的开销,跳转到一个什么都不做的函数的成本(也许编译器很容易优化它)或者每次检查一个空指针？
注意我现在只能测试小规模,看不出任何差异.如果是这种情况,我想知道.