标签: overloading

以下代码如何工作？

typedef char (&yes)[1];
typedef char (&no)[2];

template <typename B, typename D>
struct Host
{
  operator B*() const;
  operator D*();
};

template <typename B, typename D>
struct is_base_of
{
  template <typename T> 
  static yes check(D*, T);
  static no check(B*, int);

  static const bool value = sizeof(check(Host<B,D>(), int())) == sizeof(yes);
};

//Test sample
class Base {};
class Derived : private Base {};

//Expression is true.
int test[is_base_of<Base,Derived>::value && !is_base_of<Derived,Base>::value];

1. 请注意,这B是私人基地.这是如何运作的？

2. 注意operator B*()是const.它为什么如此重要？

3. 为什么template<typename T> static yes …

哪一个更好？一目了然可选参数似乎更好(代码更少,XML文档更少等),但为什么大多数MSDN库类使用重载而不是可选参数？

当您选择使用可选参数(或重载)时,是否有任何特殊事项需要注意？

考虑以下代码:

struct A
{
    void foo() const
    {
        std::cout << "const" << std::endl;
    }

    private:

        void foo()
        {
            std::cout << "non - const" << std::endl;
        }
};

int main()
{
    A a;
    a.foo();
}

编译器错误是:

错误:'void A :: foo()'是私有的.

但是当我删除私有它时它才起作用.为什么在非const的私有时不调用public const方法？

换句话说,为什么在访问控制之前会出现重载决策？这很奇怪.你认为它是一致的吗？我的代码工作,然后我添加一个方法,我的工作代码根本不编译.

拥有使用默认参数的类构造函数是一种好习惯,还是应该使用单独的重载构造函数？例如:

// Use this...
class foo  
{
private:
    std::string name_;
    unsigned int age_;
public:
    foo(const std::string& name = "", const unsigned int age = 0) :
        name_(name),
        age_(age)
    {
        ...
    }
};

// Or this?
class foo  
{
private:
    std::string name_;
    unsigned int age_;
public:
    foo() :
    name_(""),
    age_(0)
{
}

foo(const std::string& name, const unsigned int age) :
        name_(name),
        age_(age)
    {
        ...
    }
};

这两个版本似乎都有用,例如:

foo f1;
foo f2("Name", 30);

您更喜欢或推荐哪种风格？为什么？

任何人都可以提供一个简单的例子来解释Java中动态和静态多态的区别吗？

有一些类似的主题,但我找不到一个有足够答案的主题.

我想知道在Java中构造函数重载的最佳实践是什么.我已经对这个问题有了自己的想法,但我想听听更多建议.

我指的是简单类中的构造函数重载和构造函数重载,同时继承已经重载的类(意味着基类具有重载的构造函数).

谢谢 :)

在Scala 2.8中是否有一种方法来重载案例类的构造函数？

如果是的话,请把一个片段解释一下,如果没有,请解释原因？

我在测验中遇到了这个问题,

public class MoneyCalc {

   public void method(Object o) {
      System.out.println("Object Verion");
   }

   public void method(String s) {
      System.out.println("String Version");
   }

   public static void main(String args[]) {
      MoneyCalc question = new MoneyCalc();
      question.method(null);
   }
}

该程序的输出是"String Version".但是我无法理解为什么将null传递给重载方法会选择字符串版本.null是一个String变量,指向什么？

但是当代码更改为时,

public class MoneyCalc {

   public void method(StringBuffer sb) {
      System.out.println("StringBuffer Verion");
   }

   public void method(String s) {
      System.out.println("String Version");
   }

   public static void main(String args[]) {
      MoneyCalc question = new MoneyCalc();
      question.method(null);
   }
}

它给出了一个编译错误,说"方法方法(StringBuffer)对于MoneyCalc类型是不明确的"

我已经放弃了所有希望能够在PHP中重载我的构造函数,所以我真正想知道的是为什么.

有没有理由呢？它是否会产生固有的错误代码？它是否被广泛接受的语言设计不允许它,或者其他语言比PHP更好？

为什么仅通过更改返回类型来重载函数是不可能的？这将在未来的Java版本中发生变化吗？

那么,仅供参考,这在C++中是否可行？