假设有一个基类没有任何方法或属性,如class Base下面所示。
public abstract class Base {
public Base() {}
}
我们还有另一个类(Es)是从class Base派生出来的,比如class Concrete。据我所知,当我们创建Concrete类的一个实例时,创建了两个实例:一个是class Base,另一个是class Concrete。请考虑以下代码,将创建200个实例。
for(int i = 0; i < 100; i++)
Concrete c = new Concrete();
对于上述情况,这对使class
对于tic游戏,我有一个基类Player和两个派生类HumanPlayer和AIPlayer。
两个派生类都包含一个数据字段char token。这个字段是否应该包含在基类中,这样它就不需要在派生类中声明了?
现在,我没有显式地声明Player的构造函数,但是如果数据字段char token是Player的一部分,我需要声明构造函数吗?
#pragma once // include guard
#include "Board.h"
class Player
{
public:
virtual void makeAMove(Board &myB
这些问题非常直截了当,在我的任何准备中都找不到答案。在基类中未实例化基类时,派生对象实例化时,基类的共享成员如何反应?共享构造函数是否在基级被调用?如果基类没有实例化,那么在基类中定义的方法中的基类初始化一组共享成员时,如果基类没有实例化,那么给定适当的访问器,shared new()类是否可以访问共享构造函数?
Public Class Car
Protected Shared _carCount as Integer
Shared Sub New()
_carCount = 0
End Sub
Shared Public Function GetC
考虑以下代码:
class A {
};
class B : public A {
};
class C : public B{
public:
C() : A() {} // ERROR, A is not a direct base of B
};
在本例中,GCC (4.8.1,C++99)给出了正确的错误(我理解此行为):
prog.cpp:12:8:错误:输入‘a’不是‘c’的直接基
但是,如果b和a之间的继承是虚拟的,则不会发生这样的情况:
class A {
};
class B : virtual public A {
};
class C : pu
我为我的C#对象使用了NHibernate,因此我有几个模型类。
让我们假设下面的例子:
using System;
namespace TestProject.Model
{
public class Room
{
public virtual int Id { get; set; }
public virtual string UniqueID { get; set; }
public virtual int RoomID { get; set; }
public virtual float Area { g
我在一个cpp文件中有以下代码:
class Base
{
public:
//constructor
Base() = delete;
};
class Derived : public Base
{
public:
//copy constructor
Derived( const Derived & other ){};
};
int main( int argc, char* argv[] )
{
//empty
}
但是,编译cpp文件会导致错误。
exp.cpp:在复制构造函数‘派生::派生(const派生&)’中:
我有一个asbtract类的例子。另一个泛型类UsesExample使用它作为约束,带有一个新的()约束。稍后,我创建了示例类ExampleChild的子类,并将其与泛型类一起使用。但不知何故,当泛型类中的代码试图创建新副本时,它调用的不是子类中的构造函数,而是父类中的构造函数。为什么会发生这种情况?代码如下:
abstract class Example {
public Example() {
throw new NotImplementedException ("You must implement it in the subclass!");
我的班级结构如下:
class A{
A(){}
A(const A& src){}
};
class B : virtual A {
B():A(){}
B(const B& src):A(src){}
};
class C : virtual A {
C():A(){}
C(const C& src):A(src){}
};
class D : virtual B, virtual C {
D():B(),C(){}
D(const D& src):B(src),C(src){}
};
这给了我一个警告:
#include <iostream>
#include <string>
using namespace std;
class A
{
private:
int ai;
string as;
};
class B : public A
{
private:
int bi;
string bs;
};
int main()
{
B bob;
return 0;
}
类A和B具有默认构造函数。我知道A类默认构造函数将首先被调用,然后被称为B默认构造函数。但问题是,这种情
我有一门课:
export class OneComponent {
public name: string;
public age = 5;
speak() {
console.log('speaking native language');
}
}
并有第二类:
import { OneComponent } from '../one/one.component';
export class TwoComponent extends OneComponent {
constructor() {
su
因此,作为我的程序的公共API的一部分,我公开了类D,这样用户就可以从类D继承来创建自己的类。
然而,D类是致命钻石的尖端,我遇到了一个问题,用户的类正在调用类A的默认构造函数,而不是所需的参数化构造函数。
A
/ \
B C
\ /
D
|
E or F
在下面的代码中,E类是一个干净的API,但是调用错误的A构造函数。类F按预期工作,但是用户必须添加A的参数化构造函数,这很难看,因为该类是内部类。
是否有办法使E类工作按预期进行?为什么会发生这种情况?
#include<iostream>
using namespace std;
class A {
pub
我有一个类型为ItinerarySegment的数组,该类型有子类:WalkSegment、BusSegment等。
public interface ItinerarySegment
{
}
public class WalkSegment implements ItinerarySegment
{
}
public class BusSegment implements ItinerarySegment
{
}
在使ItinerarySegment数组可打包时,我应该遵循哪种策略?这里主要关注的是稍后通过方法(由方法准备)重新构造数组时如何使用它。
其中方法接受字段参数。问题出在
我知道我们不能创建抽象类实例,但我不明白为什么可以使用base调用抽象类的构造函数。
abstract class Fruit
{
public string Name { get; private set; }
public Fruit(string name)
{
Name = name;
}
}
class Apple : Fruit
{
public Apple(string name) : base(name) { }
}
Fruit f = new Fruit("Fruit"); // Coimple
我正在处理一个我不知道该如何解决的问题。我正在使用ASP.NET样板,并一直遵循本指南及其来源到T:
我在构建我的第一个存储库时遇到了问题。它给了我以下错误:错误1
'Test.EntityFramework.Repositories.TestRepositoryBase‘不包含接受0参数的构造函数。
这是储藏室:
public class UserInfoRepository : TestRepositoryBase<UserInfo, Guid>, IUserInfoRepository
{
}
而基地:
public abstract class TestR
我的教授今天在黑板上写了一些我不明白的代码。它似乎是一个调用基类构造函数的派生类构造函数,但我不确定。下面是:
class Base{
int x, y;
public:
Base(int,int);
};
class Derived: public Base{
int z;
public:
//what does the colon and the code following it do here?
Derived(int a):Base(a, a+5){
z = a;
}
};
在java和C++中,从构造函数调用被覆盖的方法是不同的。有人能解释一下为什么他们的派单方法不同吗?
我知道C++和Java的设计和发展是不同的。但是当涉及到从构造函数调用可重写的方法时,任何对语言规范为什么故意这样设计的洞察都会有所帮助。
我做这项调查的动机是ErrorProne检查:
下面是返回1的java代码
class Ideone
{
static class Simple {
public int i;
Simple() {
this.i = func();
}
public int f
我有一个带有指针的基类,它需要在所有子类的构造函数中被初始化。如何确保在子类的构造函数中初始化该变量?除了指向对象的指针之外,我本质上希望获得与创建纯虚拟函数相同的功能。有办法吗?
我的代码如下所示:
A.hpp:
class A {
protected:
A();
X *pointer;
};
B.hpp:
class B : public A {
public:
B();
};
B.cpp:
B::B() : A() {
// how do i make sure pointer gets initialized here?
}
有办法做到这一点吗?
我读到,在虚拟继承中,构造函数被称为“来自最派生的”。请考虑以下代码。在我看来,这里派生最多的类是D,然后是B和C,“最不派生的”是A,那么为什么最“基本”构造函数首先被称为“基本”构造函数,而不是“最派生的”构造函数呢?谢谢。
#include <iostream>
using namespace std;
struct A
{
A()
{
cout << "A default constructor" << endl;
}
};
struct B : virtual public A
{
我想找出1)派生类变量的初始化/实例的顺序,2)在这个代码片段中调用基类构造函数。
public class base
{
int y = 1;
public base()
{
y = 2;
function();
}
void function ()
{
System.out.println("In base Value = " + String.valueOf(y));
}
public static class derived extends base
{
int y = 3;