在Gtk中,我有一个类层次结构,如下所示:
Gtk :: ListStore派生自Gtk :: TreeModel
从Gtk::TreeView我可以得到get_model()一个Glib::RefPtr<Gtk::TreeModel>
如果我在我Gtk::Treeview的Gtk :: ListStore中使用Gtk :: TreeModel并调用get_model()我得到一个Glib::RefPtr< TreeModel >
但我想要Gtk :: ListStore的调用成员函数.
我怎么能把它Glib::RefPtr<Gtk::TreeModel>归结为Glib::RefPtr<Gtk::ListStore>.是否有标准方法或是否需要黑客攻击？或者如何使用视图和不同的商店类型进行操作.是否有任何检查功能,以便上传可以安全,可能是编译时检查或在运行时不可能？对任何文档的任何提示.
我有一个简单的方法，它接受一个函数来稍后回调：
def SimpleFunc(parm1):
print(parm1)
class CallMe:
def __init__(self, func):
self.func = func
def Call(self, parm):
self.func(parm)
caller = CallMe(SimpleFunc)
caller.Call("Hallo")
这很好用！
但我想使用一个类方法，并想在定义的对象上调用该方法作为回调：
class WithClassMethod:
def __init__( self, val ):
self.val = val
def Func(self, parm):
print( "WithClass: ", self.val, parm )
obj = WithClassMethod(1)
caller = CallMe( ??? )
caller.Call("Next")
如何将对象/方法对绑定到可调用对象？
注意：来自的代码CallMe不在我的控制之下。它来自需要处理程序功能的网络服务器。
如果我static_assert在SFINAE的条件内使用,编译器会发出错误并停止.
template < int i>
class X
{
static_assert( i != 4 );
public:
static constexpr bool value = true;
};
template < typename T >
typename std::enable_if< T::value, void>::type Do( )
{
std::cout << "one" << std::endl;
}
template < typename T >
typename std::enable_if< !T::value, void>::type Do( )
{
std::cout << "two" << std::endl;
}
int main()
{
Do<std::true_type>();
Do<std::false_type>();
// ###########
Do<X<1>>();
Do<X<4>>();
}
这是我们应该期待的行为吗？
我想检查结构/类的属性是否符合我的概念需求，但编译器抱怨。
例子：
struct N
{
char value;
auto Get() { return value; }
};
struct M
{
int value;
auto Get() { return value; }
};
void func3( auto n )
requires requires
{
//{ n.Get() } -> std::same_as<int>;
{ n.value } -> std::same_as<int>;
}
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
void func3( auto n )
requires requires
{
//{ n.Get() } -> std::same_as<char>;
{ n.value } -> std::same_as<char>;
}
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
int main() …我玩弄模板专业化和 SFINAE。
至于下面的例子，事情似乎很简单：
template <class T>
void Do(T t, typename std::enable_if<std::is_integral<T>::value >::type* = 0)
{
cout << "is integer" << endl;
}
template <class T>
void Do(T t, typename std::enable_if<std::is_floating_point<T>::value >::type* = 0)
{
cout << "is float" << endl;
}
不，我尝试过 std::is_array，但从未使用过 std::is_array 的专业化。
所以我尝试了为什么 is_array 从不匹配：
template <int num>
void Do( int a[num])
{
cout << "int array size " << num << endl;
}
void Do( int* x)
{
cout << "int*" << endl;
}
...
int …我有一个问题似乎已经在这里讨论过: CPP模板化成员函数专业化
但解决方案this->template与我的例子无关.
以下代码失败:
error: invalid operands of types '<unresolved overloaded function type>' and 'int'
to binary 'operator<'
与gcc 4.8.1
class Base { public: virtual int Do(){return 0;} };
class State1: public Base {};
class State2: public Base {};
template <typename ... T> class SM;
template <class StateBase, class HeadState, class ... States >
class SM<StateBase, HeadState, States...> : public SM< StateBase, States...>
{
protected:
HeadState headState;
template<int cnt> StateBase* GetNextState ( unsigned int index ) { …我有两个 git 存储库，它们应该保持同步并且不能同时访问。一个在工作，一个在家里，没有网络连接。
如何处理这个简单的设置？
我尝试过的：
我有一个克隆，它“知道”存储库并存在于便携式硬盘上。
假设有人在“工作”创建了一个新分支，我想将它转移到回购“家”。这该怎么做？
如果我只做一个，git pull我会在我的克隆上得到以下内容：
$ git branch --list --all
*master
origin/HEAD -> origin/master
origin/bugfix_component_condition_destruction_fail
origin/master
origin/remove_stoplist_copy_and_erase
问：这是否仅意味着我的本地克隆“知道”某处有这些列出的分支，并且除了本地存在的名为“master”的分支之外，我的克隆上没有真实数据？
很容易将 master 拉/推到两个 repos。但是我的本地克隆中似乎不存在任何其他人。我是否必须将每个远程分支跟踪到我克隆的本地分支，然后将其传输到另一个存储库？
问：如果将推送两个 repos 提交，是否有任何典型的方法来处理两个 repos 以使它们同步？
问：有没有什么技巧可以获取所有远程分支的所有信息和内容。
对我来说，回购的“克隆”意味着什么有点神秘？它似乎不是真正的克隆，而只是一些元数据和主分支。这是正确的吗？
编辑：
如果我开始，gitk --all我会看到在分支中完成的所有更改。看起来分支的内容在克隆中。
但如果我这样做：
$git checkout -b remove_stoplist_copy_and_erase --track remotes/origin/remove_stoplist_copy_and_erase
error: Not tracking: ambiguous information for ref refs/remotes/origin/remove_stoplist_copy_and_erase
Switched to a new branch 'remove_stoplist_copy_and_erase'
所以我做了：
$git checkout origin/remove_stoplist_copy_and_erase
$git checkout -b remove_stoplist_copy_and_erase
现在推送它： $git push --set-upstream ex remove_stoplist_copy_and_erase
我担心必须为两个遥控器上的所有分支手动执行所有这些操作才能使两者同步。这项工作是否有一些“最佳实践”？
结构化绑定只能与某种"struct"一起用作返回值吗？
回馈任何类/结构,例如元组在这里工作正常:
auto f()
{
return std::make_tuple(1,2.2);
}
是否有能够实现以下目标的东西:
auto f() -> [int,double]
{
return { 1, 2.2 }; // maybe with or without braces arround
}
今天我在 eigen 中做了我的第一步，并找到了以下解决方案来获得交点：
#include <Eigen/Dense>
using namespace Eigen;
using namespace std;
int main() {
// Calc intersection of line ac with bd:
Vector2f a(8,2);
Vector2f b(9,5);
Vector2f c(6,6);
Vector2f d(5,9);
Matrix2f xx;
xx << c-a, b-d;
cout << "Here is the matrix xx:\n" << xx << endl;
Vector2f x = xx.colPivHouseholderQr().solve(b-a);
Vector2f intersect1( a + x(0)* ( c-a ) );
Vector2f intersect2( b + x(1)* ( d-b ) );
cout << "intersect1\n" << intersect1 << std::endl;
cout << "intersect2\n" << …我有一些模板化类类型，例如 A、B、C，如下所示：
template < typename T >
class A{};
template < typename T >
class B{};
template < typename T >
class C{};
现在我想要一个函数，它通常接受任何类型，例如：
template < typename T>
void Func()
{
std::cout << "Default " << __PRETTY_FUNCTION__ << std::endl;
}
现在我想将该函数专门化为仅接受给定的模板类之一，例如：
template < typename T>
void Func<A<T>>()
{
std::cout << "All A Types " << __PRETTY_FUNCTION__ << std::endl;
}
这是不允许的，因为它只是部分专业化。好的。
我认为concept可能有帮助，但感觉我想得太复杂了。我的解决方案是：
template < typename T, template <typename > typename OUTER >
bool Check;
template < typename INNER, template …