我很高兴使用子模块来跟踪我的项目所依赖的所有库.问题是我正在使用一个名为core-plot的库,它只有一个公共的mercurial存储库.我可以在一个只读的Git存储库中镜像它,但这是我得到的最佳选择吗？我曾经看到Mercurial中有模块来跟踪Git中的内容.有人知道是否存在相反的方式？
我有一组非正交的策略,它们都实现了一个通用的命名方法,策略添加了安全检查.我希望用户能够组合策略以允许更复杂的验证,而无需手动为每个组合案例创建策略.我的方法是创建一个新的策略类来组合其他人.
下面的简化示例将C显示为组合类,此处将方法ID组合在一起.当在C上调用id时,预期的结果是顺序调用每个基类的id.
#include <iostream>
using namespace std;
struct A
{
void id() { cout << "A ";}
};
struct B
{
void id() { cout << "B ";}
};
template<class A, class... As>
struct C : public A, public As...
{
void id()
{
A::id();
As...::id(); // This line does not work, it is illustrative.
}
};
int main()
{
C<A, B> c;
c.id();
//expected: result A B
}
问题是:是否有可能扩展为...以某种方式这样做而不使用递归方法,只使用...运算符？
我发现了一些这样的代码:
class foo{
int a;
public:
foo(int v) : a{v} {}
bool operator==(const foo& rhs) const&{
return (rhs.a == a);
}
};
它编译并运行.
我想知道在运算符==中对此引用(&)有什么好处(或缺点).
我得到了一个类,当实例化时需要获得一些独特的ID才能工作.最初我想过使用一个分配和增加的静态函数.我不需要它们是连续的,只是唯一的.
class A {
int id_1;
int id_2;
int id_3;
public:
static int last_id=0;
static int get_id(){ return A::last_id++; }
...
A(){ id_1 = A::get_id(); id_2 = A::get_id(); id_3 = A::get_id(); }
};
现在,我正在考虑进行多线程处理.我认为静态函数将成为一个瓶颈,因为我在开始时构建了几十万个这些对象的实例.我不会在程序结束之前销毁任何实例,因此在初始化之后它们是固定的.无论如何,它们不是在编译时计算的,因为数量取决于命令行参数.
我想到的另一种选择是使用内存地址,它们至少在一台计算机中是独一无二的.
就像是:
class A {
int* id_1;
int* id_2;
int* id_3;
public:
static int last_id=0;
static int get_id(){ return A::last_id++; }
...
A(){ id_1 = new int(0); id_2 = new int(0); id_3 = new int(0); }
~A() { delete id_1; delete id_2; delete id_3(); }
}; …我有一个接收多种类型的模板类，接收到的每种类型都是两个选项之一的子类。我想根据标识它们的父类以不同的方式扩展它们。这相当于对可变参数模板参数实现“过滤器”。
例如：
class A{};
class B{};
template<class... C>
struct F{
std::tuple<types_derived_by<A, C>...> fn(types_subclassing<B, C>...){}
};
types_衍生_by 模板函数应该生成一个可变参数模板包，其中包含 C 中从 A 或 B 派生的所有类型。
例如：
struct DA : public A{};
struct DB : public B{};
int main(){
F<DA, DB> f;
//f has a member function: DA fn(DB);
}
我正在使用 C++11，但如果有必要，我可以迁移到 c++14。