C++ 中的多态性：我是否必须为子类函数提供与父类函数相同的参数 - 如何重载

发布于 2024-11-18 03:46:42 字数 418 浏览 0 评论 0原文

如果我有一个像这样的父类：

class Parent {
protected:
   virtual void foo(type1 var1, type2 var2);
}

和一个子类：

class Child : public Parent {
   foo(type1 var1, type2 var2);
}

但是如果 Child 中的 foo 函数不需要 var1 和 <代码>var2？有没有办法告诉编译器不要为这些变量提供内存，因为它们没有被使用？或者，你如何超载它？不过，结合重载和多态性......你如何做到这一点（如果你可以/愿意！）。

谢谢。

原文

If I have a parent class like this:

class Parent {
protected:
   virtual void foo(type1 var1, type2 var2);
}

and a child class:

class Child : public Parent {
   foo(type1 var1, type2 var2);
}

but what if the foo function in Child doesn't need var1 and var2? Is there a way to tell the compiler not either not give memory to these variables because they're not being used? Or, how do you overload it? Combining overloading and polymorphism though.. how do you do that (if you can/would!).

Thank you.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

梦回旧景 2024-11-25 03:46:42

如果子级的函数签名与父级的不同，则子级有两个函数，并且重载。

编译器将根据您提供的参数类型选择正确的参数。如果愿意，可以修改其参数并将工作转发给另一个函数。

例如，

class Child : public Parent {
   using Parent :: foo;
   void foo (type1 var1);
};

Child c;
child .foo (type1()); // Valid
child .foo (type1(), type2()); // Valid, calls Parent::foo

void Child :: foo (type1 x) {
    Parent :: foo (x+1, blah);
}

或者，如果您想消除歧义。

class Child : public Parent {
   void foo (type1 var1, type2 var2);
};

Child c;
child .foo (type1(), type2()); // Valid, calls Child::foo
child .Parent :: foo (type1(), type2()); // Valid.

覆盖是另一回事。

class Parent {
    virtual void foo () {}
};

class Child1 : parent {
    void foo ();
};

class Child2 : parent {
    void foo ();
};

void call_foo (Parent & p) {p .foo ();}

Parent p;
Child1 c1;
Child2 c2;
call_foo (p); // Calls Parent::foo
foo (c1);     // Calls Child1::foo
foo (c2);     // Calls Child1::foo

If the child's function signature is different to the partent's, then the child has two functions which are overloaded.

The compiler will pick the right one according to which kind of arguments you give it. One can modify its arguments and forward the work to another function if it likes.

For example,

class Child : public Parent {
   using Parent :: foo;
   void foo (type1 var1);
};

Child c;
child .foo (type1()); // Valid
child .foo (type1(), type2()); // Valid, calls Parent::foo

void Child :: foo (type1 x) {
    Parent :: foo (x+1, blah);
}

Or, if you want to disambiguate.

class Child : public Parent {
   void foo (type1 var1, type2 var2);
};

Child c;
child .foo (type1(), type2()); // Valid, calls Child::foo
child .Parent :: foo (type1(), type2()); // Valid.

Overriding is something else.

class Parent {
    virtual void foo () {}
};

class Child1 : parent {
    void foo ();
};

class Child2 : parent {
    void foo ();
};

void call_foo (Parent & p) {p .foo ();}

Parent p;
Child1 c1;
Child2 c2;
call_foo (p); // Calls Parent::foo
foo (c1);     // Calls Child1::foo
foo (c2);     // Calls Child1::foo

回复收藏 0 原文