在问我的问题之前,我试着在网上搜索,但我不确定我需要使用什么术语,我也没有找到对我的问题的解释。如果这样的答案已经存在,请随时告诉我:)
下面是一个小示例:
class IObject;
class ClassA;
class Base {
public: void Method(IObject * object) {}
};
class Derived : public Base {
public: void Method(ClassA * objet) {}
};
class IObject {};
class ClassA : public IObject {};
int mai
在C#中,基类的虚方法可以被它的派生类覆盖或隐藏,例如
using System;
class A {
public virtual void M() {
System.Console.WriteLine("A");
}
}
class B: A {
public override void M() {
System.Console.WriteLine("B");
}
}
class C: A {
public new void M() {
System.Console.WriteLine("C");
}
}
cl
我不明白以下的限制:
class Base
{
virtual doFoo() = 0;
};
class Derived : public Base
{
public:
void doStuff() { doFoo(); } //compile error, doFoo is a private member of Base
};
当然,解决方案是重新声明派生类中的成员,但我觉得有些奇怪:
class Derived : public Base
{
public:
void doStuff() { doFoo(); }
private:
v
我对C++编程非常陌生,所以我想编写一些简单的代码来适应语法。我暂时故意忽略了指点和参考。
在编码过程中,我正在练习继承,我想创建一个类手,它代表一只牌手。基类有一个名为update()的函数,用于在构造时初始化“总计”和“符号”属性。此外,还可以使用add()函数向手添加卡片,该函数向手添加卡片,并触发update()以适当地更新属性。
#include<vector>
class Hand
{
public:
std::vector<int> cards;
int total;
std::string notation; // Abbrev
当使用派生类的对象访问"base“的foo()时。
#include <iostream>
class base
{
public:
void foo()
{
std::cout<<"\nHello from foo\n";
}
};
class derived : public base
{
public:
void foo(int k)
{
std::cout<<"\nHello from foo with va
我在c++中尝试了几个函数隐藏的概念。因此,在派生类中,我使用了范围解析操作符using base::fun来提供派生类中基类的作用域。我的目标是打印cout<<" base "<< x;,但是输出只输出派生类cout。有什么原因,为什么和如何解决?也就是说,它应该同时打印基类和派生类值。我是c++新手,很抱歉mistakes.The代码如下所示:
#include <stdio.h>
#include <iostream>
using namespace std;
class base
{
public:
int fun(in
假设有两类:基类和派生类。下面列出了代码。我的问题是,程序如何知道d.print() (在代码中使用A标记)是为了调用Derived::print()而不是Base::print()
请注意,我故意添加using Base::print;来混淆编译器。这两个print()方法具有相同的签名(对吗?)并且没有因为using语句而相互隐藏。
#include <iostream>
using namespace std;
class Base {
public:
void print() { cout << "print() of Base is call
我有个密码-
from statistics import mean
from random import choice
from random import sample
import networkx as nx
class MyGraph(nx.Graph):
def __init__(self, num_nodes, target_deg, target_wght, max_wght=5):
super().__init__()
self.num_nodes = num_nodes
self.target_deg = tar
下面的C++代码产生编译错误。
编译器(gcc 5.2.0)抱怨说,在第15行,它找不到调用‘Derived::test_func()’的匹配函数;但是,如果test_func()从BasetoIn派生,那么它编译就没有错误。
class Base {
public:
int test_func();
};
class Derived : public Base {
public:
template <typename T>
int test_func(T t);
};
template <typename T>
int Derived::test_f
问题:
在下面的代码中,“this”指针指向基类和派生类中的不同事物,尽管它在技术上包含相同的地址。当'this‘指针与继承一起使用时发生了什么。(如有任何帮助,我们将不胜感激。(谢谢)
#include <iostream>
using namespace std;
// this pointer and inheritance.
class base {
public:
int x;
base() {
x = 10;
}
void func() {
cout<< this->x << endl; // 10
也许我在继承和多态性方面的知识并不是我想的那样。有没有人能说点什么?
设置(问题的平凡):
class X {
};
class Y {
};
class Base {
public:
void f( X* ) {}
};
class Child: public Base {
public:
void f( Y* ) {}
};
问:这应该是可行的,对吧?
int main( void ) {
X* x = new X();
Y* y = new Y();
Child* c = new Child();
c->f( x );
c->
我一直认为基类的公共方法确实由派生类继承,甚至认为派生类没有对特定方法的定义。例如
#include <iostream>
using namespace std;
class A {
public:
int f() { cout << 3; return 0;}
int f(int x) {cout << x; return 0;}
};
class B: public A {
public:
int f() {std::cout << 5; re
子类中的super关键字(Savings)不是指Account类。我试图通过使用Account类引用super.total类的总实例,但是它给出了Savings类的总数。
total和super.total是一样的。此外,当我在控制台中打印super.getClass()时,它会给出子类(Savings),而不是超类(Accounts)。
Savings.java
public class Savings extends Account {
public Savings(int initial, User owner, double history, double
我对这两个术语有点困惑,很高兴能澄清一些疑问。
据我所知,function overloading意味着在同一个类中有多个方法具有相同的名称,但参数的数量不同,参数的类型不同,或者参数的序列与返回类型无关,这对损坏的函数名称没有任何影响。
上述定义是否也包括"....in同一类或跨相关类(通过继承相关).....“
Function Overriding与虚函数、相同的方法签名(在基类中声明为虚)以及在子类中的实现被重写有关。
我在想一个场景,以下是代码:
#include <iostream>
class A
{
public:
void doSomet
我在努力让这个在酒杯里显得优雅.
我有一个基类,它包含一个重载的方法create:
class Base {
public:
virtual Foo *create(ClassA &, ClassB &) = 0;
Foo *create(int id) {
// get ClassA a and ClassB b from an internal store related to id
return create(a, b);
}
};
当然,这是一口没有麻烦的东西。
在其他位置/存储库中,有几个不同的Base派生类,它
假设您有一个名为FormBase的表单,所有其他窗体都继承自此表单。
例如,我有public class Form formTest : FormBase
我现在在formTest中拥有的是:
public class Form formTest : FormBase
{
public formTest()
{
InitializeComponent();
Program.MainForm.AddToFormSizes(this, this.Size);
}
}
此代码将formTest实例添加到主窗体上的字典中,并使用其size。
这是
我有一个带有虚函数的基类- int Start(bool)在派生类中有一个同名但具有不同签名的函数-
int Start(bool, MyType *)
但不是虚拟的
在派生的Start()中,我想调用基类Start()
int Derived::Start(bool b, MyType *mType)
{
m_mType = mType;
return Start(b);
}
但是它给出了编译错误。
"Start' : function does not take 1 arguments"
但是,Base::Start(b)是有效的
在C#中,上面的代
我有一个基类,它有一个叫做Update的方法:
Start Update
Code block 1 (An If statement)
Code block 2 (Setting a variable based on the If result)
Code block 3 (A switch which is setting something)
End Update
代码的执行顺序是重要的,因此它们不能被转移。
我还有一个派生类,它需要更多的代码。但是,这段代码必须介于代码块1和2之间。因此,当我重写整个代码块时,它会是这样的:
Start Update
我有一个接口IDeepCloneable,用于实现通用的深度复制。我还有一个基类和一个派生类,每个类都实现了IDeepCloneable。我遇到了派生类的问题。
以下是代码:
public class Program
{
public static void Main()
{
var a = new BaseClass();
var ac = a.DeepClone();
var b = (BaseClass)(new DerivedClass());
var bc = b.DeepClone();
}
可能重复:
#include <iostream>
using namespace std;
class B {
public:
virtual void fn1(void) {cout << "class B : fn one \n"; }
virtual void fn2(void) {cout << "class B : fn two \n"; }
};
class D: public B {
void fn1(void) {cout << "class D : fn
我有基类A
public class A
{
public virtual void Method(A parameter)
{
Console.WriteLine(MethodBase.GetCurrentMethod());
}
public virtual void Method(B parameter)
{
Console.WriteLine(MethodBase.GetCurrentMethod());
}
}
内嵌B
public class B : A
{
public virtual voi
考虑以下代码:
public abstract class Test1
{
public object Data { get; set; }
}
public abstract class Test2<T> : Test1
{
public T Data { get; set; }
}
这将产生以下警告:
'Test2.Data‘隐藏继承的成员'Test1.Data’。如果有意隐藏,请使用新关键字。
为什么这只是一个警告和添加“新”关键字将有什么影响?
根据我的测试,一旦添加了“新”关键字,我就找不到任何不同之处。
不要误解我的意思,我完全赞成
为什么d.f(1)在这段代码中调用Derived::f?
在决定调用哪个f时,using Base::f起作用了吗?
#include <iostream>
using namespace std;
struct Base {
void f(int){
cout << "\n f(Base) is called" ;
}
};
struct Derived : Base {
using Base::f ; // using-declarations but still Drived function i
我有以下代码,它编译没有任何错误或警告。
#include<iostream>
using namespace std;
class Father
{
public:
int foo()
{
cout<<"int foo";
return 111;
}
};
class Son: public Father
{
public:
long foo()
{
cout<<"long foo";
return 222;
}
};
我有一个关于如何通过继承访问同名成员的问题。例如,
class Base {
public:
int i;
};
class Derived1 : public Base {
public:
int i;
// how to access the i in the base class here?
};
int main() {
Derived1 d;
cout<<d.i; //which is it is?
//how to access the different i he