Tag: 重载

while（true）的独特重载分辨率

当遇到这种奇怪的情况时，我正在实现同步/asynchronous重载： 当我有一个没有参数或返回值的常规lambdaexpression式时，它会通过Action参数进入Run重载，这是可预测的。 但是，当lambda有一段while (true)在它使用Func参数进入重载。 public void Test() { Run(() => { var name = "bar"; }); Run(() => { while (true) ; }); } void Run(Action action) { Console.WriteLine("action"); } void Run(Func<Task> func) // Same behavior with Func<T> of any type. { Console.WriteLine("func"); } 输出： 行动 FUNC 那么，怎么可能呢？ 是有原因的吗？

为什么/在Python中`x == y`调用`y .__ eq __（x）`？

Python文档明确指出x==y调用x.__eq__(y) 。 不过，在很多情况下，情况恰恰相反。 在哪里logging何时或为什么发生这种情况，以及如何确定我的对象的__cmp__或__eq__方法是否会被调用。 编辑：只是为了澄清，我知道__eq__被称为优先__cmp__ ，但我不清楚为什么y.__eq__(x)被优先调用x.__eq__(y) ，当后者是什么文档状态将会发生。 >>> class TestCmp(object): … def __cmp__(self, other): … print "__cmp__ got called" … return 0 … >>> class TestEq(object): … def __eq__(self, other): … print "__eq__ got called" … return True … >>> tc = TestCmp() >>> te = TestEq() >>> >>> 1 == tc __cmp__ got called […]

为什么不能重载类模板？

读这个问题让我怀疑：是否有一个技术原因不允许类模板重载？ 通过重载，我的意思是有几个相同名称的模板，但不同的参数，例如 template <typename T> struct Foo {}; template <typename T1, typename T2> struct Foo {}; template <unsigned int N> struct Foo {}; 编译器pipe理处理重载的函数和函数模板，是不是可以应用类模板相同的技术（例如名称修改）？ 起初，我认为也许这会在单独使用模板标识符时造成一些模糊性问题，但唯一可能发生的情况是将其作为模板模板parameter passing，因此可以使用参数的types来select适当的超载： template <template <typename> class T> void A {}; template <template <unsigned int> class T> void B {}; A<Foo> a; // resolves to Foo<T> B<Foo> b; // resolves to Foo<N> […]

constexpr超载

相关： 函数返回constexpr不编译 我觉得constexpr在C ++ 11中的用处是有限的，因为它不能定义两个函数，否则它们会有相同的签名，但是一个是constexpr，另一个是不是constexpr。 换句话说，如果我可以有一个constexst std :: string构造函数，它只需要constexpr参数，而一个非constexpr std :: string构造函数用于非constexpr参数将是非常有帮助的。 另一个例子是理论上复杂的函数，可以通过使用状态来提高效率。 你不能用constexpr函数轻松做到这一点，所以你只剩下两个select：如果你传递了非constexpr参数，或者完全放弃了constexpr（或者写了两个单独的函数，但你可能不知道要调用哪个版本）。 因此，我的问题是： 标准兼容的C ++ 11实现是否可以允许基于constexpr参数的函数重载，还是需要更新标准呢？ 如果不允许，是否故意不允许？ @NicolBolas：说我有一个函数，将一个enum映射到一个std::string 。 假设我的enum从0到n – 1 ，最直接的方法是创build一个大小为n的数组，填充结果。 我可以创build一个static constexpr char const * []并在返回时构造一个std::string （每次调用该函数时支付创build一个std::string对象的代价），或者我可以创build一个static std::string const []并返回我查找的值，在第一次调用函数时支付所有std::string构造函数的代价。 看起来更好的解决scheme是在编译时在内存中创buildstd::string （类似于char const *所做的），但唯一的方法是提醒构造函数它有constexpr参数。 除了std::string构造函数以外，我认为find一个例子，如果你可以忽略constexpr的需求（从而创build一个非constexpr函数），那么你可以创build一个更多的例子高效的function。 考虑这个线程： constexpr问题，为什么这两个不同的程序在g ++中运行的时间不同？ 如果我用一个constexpr参数来调用fib ，那么我完全可以比编译器优化掉函数调用来做得更好。 但是如果我用一个非constexpr参数来调用fib ，我可能希望让它调用我自己的版本来实现像memoization（这将需要状态），所以我得到的运行时间类似于我通过编译的时间一个constexpr论据。

如何重载Python的__bool__方法？

可能重复： 在python中定义一个类的“boolness” 我认为这应该打印“假”，为什么打印“真”？ >>> class Foo(object): … def __bool__(self): … return False … >>> f = Foo() >>> if f: … print "True" … else: … print "False" … True >>>

重载括号操作符来获取和设置

我有以下class级： class risc { // singleton protected: static unsigned long registers[8]; public: unsigned long operator [](int i) { return registers[i]; } }; 你可以看到我已经实现了“获取”的方括号操作符。 现在我想实现它，即： risc[1] = 2 。 如何做呢？

可选函数参数：使用默认参数（NULL）还是重载函数？

我有一个处理给定vector的函数，但是如果没有给出，也可以创build这样一个vector。 在这种情况下，我看到两个devise选项，其中函数参数是可选的： 使它成为一个指针，并使其默认为NULL ： void foo(int i, std::vector<int>* optional = NULL) { if(optional == NULL){ optional = new std::vector<int>(); // fill vector with data } // process vector } 或者有两个重载名称的函数，其中一个忽略了参数： void foo(int i) { std::vector<int> vec; // fill vec with data foo(i, vec); } void foo(int i, const std::vector<int>& optional) { // process vector } […]

通过引用重载多个函数对象

在C ++ 17中，实现一个overload(fs…)函数是很简单的，给定任意数量的参数fs…满足FunctionObject ，返回一个新的函数对象 ，其行为类似于fs…的重载。 例： template <typename… Ts> struct overloader : Ts… { template <typename… TArgs> overloader(TArgs&&… xs) : Ts{forward<TArgs>(xs)}… { } using Ts::operator()…; }; template <typename… Ts> auto overload(Ts&&… xs) { return overloader<decay_t<Ts>…>{forward<Ts>(xs)…}; } int main() { auto o = overload([](char){ cout << "CHAR"; }, [](int) { cout << "INT"; }); o('a'); // […]

C ++重载parsing

给出下面的例子，为什么我必须明确地使用语句b->A::DoSomething()而不仅仅是b->DoSomething() ？ 编译器的重载决议不应该找出我正在谈论的方法吗？ 我正在使用Microsoft VS 2005.（注意：在这种情况下使用虚拟不起作用。） class A { public: int DoSomething() {return 0;}; }; class B : public A { public: int DoSomething(int x) {return 1;}; }; int main() { B* b = new B(); b->A::DoSomething(); //Why this? //b->DoSomething(); //Why not this? (Gives compiler error.) delete b; return 0; }

方法重载。 你能过度使用吗？

定义几种不同的filter返回相同形状的数据的方法时，更好的做法是什么？ 显式方法名称或重载方法？ 例如。 如果我有一些产品，我从数据库拉 明确的方式： public List<Product> GetProduct(int productId) { // return a List } public List<Product> GetProductByCategory(Category category) { // return a List } public List<Product> GetProductByName(string Name ) { // return a List } 重载方式： public List<Product> GetProducts() { // return a List of all products } public List<Product> GetProducts(Category category) { // […]