标签: overloading

我有两个重载方法,一个带有可选参数.

void foo(string a)  { }  
void foo(string a, int b = 0) { }  

现在我打电话给:

 foo("abc");

有趣的是第一次重载被调用.为什么第二次重载的可选值设置为零？

说实话,我希望编译器带来一个错误,至少是一个警告,以避免无意中执行错误的方法.

这种行为的原因是什么？为什么C#团队以这种方式定义它？

我已经看到它说一个operator=带有相同类型by-value的参数的文件在C++ 11中既作为复制赋值运算符又作为移动赋值运算符:

Foo& operator=(Foo f)
{
    swap(f);
    return *this;
}

替代方案的重复次数将超过两倍,并且可能出现错误:

Foo& operator=(const Foo& f)
{
    Foo f2(f);
    swap(f2);
    return *this;
}

Foo& operator=(Foo&& f)
{
    Foo f2(std::move(f));
    swap(f2);
    return *this;
}

在什么情况下,ref-to-const和r-value重载优先通过值,或何时需要？我正在考虑std::vector::push_back,例如,它被定义为两个重载:

void push_back (const value_type& val);
void push_back (value_type&& val);

在第一个示例中,pass by value 用作复制赋值运算符和移动赋值运算符,无法push_back在Standard中定义为单个函数？

void push_back (value_type val);

我有一些代码

#define DEBUG_PRINT(x,...) \
    do \
    {\
        _Pragma("GCC diagnostic push") \
        _Pragma("GCC diagnostic ignored \"-Wunused-value\"") \
        __typeof__((0,x)) _x = x; \
        _Pragma("GCC diagnostic pop") \
        DEBUG_PRINT_PTR((#x), &_x, __VA_ARGS__);\
    } while(0)


//The repetition of debug_print_printf_specifier is to avoid repetition for custom types.
#define DEBUG_PRINT_PTR(xstr, xp,...) \
_Generic((*xp), \
const char *: debug_print_printf_specifier(xstr, (void *)xp, TYPE_PTR_TO_PRINTF_SPECIFIER(xp), __FILE__, __LINE__, _my_func__, debug_print_options_apply_group_options(&((debug_print_options){__VA_ARGS__}))),\
char *: debug_print_printf_specifier(xstr, (void *)xp, TYPE_PTR_TO_PRINTF_SPECIFIER(xp), __FILE__, __LINE__, _my_func__, debug_print_options_apply_group_options(&((debug_print_options){__VA_ARGS__}))),\
int: debug_print_printf_specifier(xstr, (void *)xp, TYPE_PTR_TO_PRINTF_SPECIFIER(xp), __FILE__, __LINE__, _my_func__, debug_print_options_apply_group_options(&((debug_print_options){__VA_ARGS__}))),\
float: debug_print_printf_specifier(xstr, …

我遇到了问题,因为我正在使用some_widget_instance.delete()删除Widget.我还有一个名为WidgetFile的模型,它有一个覆盖delete()方法,这样我就可以在删除WidgetFile时删除硬盘上的文件.我遇到的问题是,如果我删除一个Widget,它有与之相关的WidgetFiles:

class WidgetFile(models.Model):

    widget = models.ForeignKey(Widget)

好吧,当我删除该Widget时,它的WidgetFiles被删除但是delete()方法不会触发并执行我的额外硬盘驱动器.任何帮助深表感谢.

函数重载的用途/优点是什么？

想要为基于REST的API使用相同的URL进行GET/PUT/DELETE/POST,但是当关于Actions的唯一不同之处是它接受哪个HTTP谓词时,它认为它们是重复的!

"Type已经定义了一个名为'Index'的成员,它具有相同的参数类型."

我说的是什么呢？这个只接受GET,这个只接受POST ...应该可以共存吗？

怎么样？

示例代码是:

    public class OverloadingTest {

       public static void test(Object obj){
           System.out.println("Object called");
       }

       public static void test(String obj){
           System.out.println("String called");
       }

       public static void main(String[] args){
           test(null);
           System.out.println("10%2==0 is "+(10%2==0));
           test((10%2==0)?null:new Object());
           test((10%2==0)?null:null);
   }

输出是:

名为
10%2 == 0的 字符串为true
称为
String的对象称为

第一次调用test(null)带String参数调用方法,这是可以理解的The Java Language Specification.

1)任何人都可以解释我test()在前面的电话中调用的基础吗？

2)当我们提出时,说一个if条件:

    if(10%2==0){
        test(null);
    }
    else
    {
        test(new Object());
    }

它总是使用String参数调用方法.

编译(10%2)时编译器会计算表达式吗？我想知道表达式是在编译时还是在运行时计算的.谢谢.

我们刚刚在代码中找到了这些:

public static class ObjectContextExtensions
{

    public static T Find<T>(this ObjectSet<T> set, int id, params Expression<Func<T, object>>[] includes) where T : class
    {
        ...
    }

    public static T Find<T>(this ObjectSet<T> set, int id, params string[] includes) where T : class
    {
       ...
    }
}

正如你所看到的,除了params.之外,它们具有相同的签名.

它们被用于多种方式,其中之一:

DBContext.Users.Find(userid.Value); //userid being an int? (Nullable<int>)

对我来说奇怪的是,它解决了第一次超载.

Q1:为什么这不会产生编译错误？

Q2:为什么C#编译器将上述调用解析为第一种方法？

编辑:只是为了澄清,这是C#4.0,.Net 4.0,Visual Studio 2010.

众所周知,C++标准定义了两种形式的全局分配函数:

void* operator new(size_t);
void* operator new[](size_t);

而且,C++标准草案(18.6.1.2 n3797)说:

227)运算符new或operator delete不直接负责注意数组的重复次数或元素大小.这些操作在数组new和delete表达式的其他位置执行.但是,数组新表达式可以将operator参数增加到operator new以获得存储补充信息的空间.

让我困惑的是:

如果我们void* operator new[](size_t);从标准中删除,而只是使用该void* operator new(size_t)怎么办？定义冗余全局分配函数的基本原理是什么？

所以我遇到了这个问题:我需要用std::vector<int>它之前的最小值(包括在内)替换每个元素.

自然std::partial_sum想到的-如果我能通过std::min的BinaryOp,它会做的工作.

事实证明我不能这样做,因为它std::min<int>是一个重载函数 - 它适用于两者int,initializer_list<int>并且partial_sum模板不能用未知类型实例化.

通常这是通过一个模板类解决operator(),像std::plus<void>等,但标准库似乎并不有一个min和max.

我觉得我要么必须实现自己的T min<T>(T,T),这将是一个完全克隆,std::min除了没有initializer_list超载,或实现我自己的class min类似std::plus.两者都觉得有点不对,因为人们会期望标准库有这样一个基本的东西,而且基本的东西通常很难实现:)

所以这是我的问题:

1. 有没有正确的方法来解决问题？即不引入新的模糊结构/编写超过几行代码.
2. 在引入initializer_list过载之后,假设这成为C++ 11中的问题是否正确min？那么C++ 11打破了依赖于显式实例化的代码std::min？

谢谢!