在C++中,在派生类中减少返回类型的cv-限定符是有效的:
class Base {
virtual const Base* f();
};
class Derived : public Base {
Base* f() override;
};
这对指向基本类型的指针有效吗?
class Base {
virtual const int* f();
};
class Derived : public Base {
int* f() override;
};
在C++中,子类在重写虚拟函数时可以指定不同的返回类型,只要返回类型是原始返回类型的子类(并且两者都作为指针/引用返回)。
是否也可以将此功能扩展到智能指针?(假设智能指针是某个模板类)
为了说明:
class retBase {...};
class retSub : public retBase {...};
class Base
{
virtual retBase *f();
};
class Sub : public Base
{
virtual retSub *f(); // This is ok.
};
class smartBase
{
v
我正在尝试为Arduino编译一个来自的例子。我得到了这个错误:
In file included from sha1test.pde:1:
C:\Program Files (x86)\Arduino\libraries\Sha/sha1.h:26: error: conflicting return type specified for 'virtual void Sha1Class::write(uint8_t)'
C:\Program Files (x86)\Arduino\hardware\arduino\cores\arduino/Print.h:48: error
我有一个第一个类A,它包含一个带有虚方法的迭代器嵌套类:
template <typename T >
class A {
public:
class iterator {
public:
virtual ~iterator() {};
virtual T& operator++();
};
virtual iterator begin() const = 0;
};
我有第二个B类,它覆盖了虚拟方法:
template <typename T >
class B :
在下面的代码中,我得到了以下编译错误:
1>c:\users\mittamani\desktop\06-10\over_riding_test\over_riding_test\over_riding_test.cpp(33) : error C2555: '_D1::fun': overriding virtual function return type differs and is not covariant from 'Base2::fun'
1> c:\users\mittamani\desktop\06-10\over_ri
此代码在g++ 6.1下编译成功,但在clang 3.8下出现错误:
class C;
class Base {
public:
virtual const C *getC();
};
class Derived : public Base {
public:
virtual C *getC();
};
clang产生的错误如下:
$ dev/compilers/linux-x86_64-2.12.2/clang3.8/bin/clang++ -Wall -c testcovariantreturn.cxx
testcovariantreturn.cxx:10:20:
我正在尝试制作一个名为Matrix的界面。有两个类将实现此接口。其中之一被称为RegMatrix (正则矩阵)。现在,我正在尝试为类RegMatrix和OthMatrix构建迭代器,让用户能够迭代“Matrix”对象。问题是,对于方法begin()和end(),我得到了一个错误"invalid covariant return type for 'virtual RegMatrix::iterator RegMatrix::begin()'“,可能是因为其中一个方法返回RegMatrix::iterator,而基类返回Matrix::iterator。我不明白这到底是错
有没有可能实现下面的工作?基本上,我希望Ptr成为Ptr的可接受的返回类型替换。
template<typename T>
class Ptr {
public:
explicit Ptr (T * ptr) : ptr(ptr) {}
T * ptr;
};
class A {
virtual Ptr<A> foo () {
return Ptr<A>(NULL);
}
};
class B : public A {
virtual Ptr<B> foo () { // BAD! P
以下总结了我对C#中差异的理解。如果你能告诉我问题出在哪里,我会很感激,因为我读过埃里克·利珀特( Eric )在上发表的那篇文章,我无法理解其中的大部分内容。
方差是指一种类型的转换(或者像Eric Lippert所说的那样的投影)可以保持赋值兼容性(协方差),或者逆转它(反方差),或者既不能保持它,也不能逆转它(不变性)。也就是说,如果我是T中的协变量转换,其中T是一组类型,那么对于T中的任何T1和T2类型,如果T1可分配给T2,则I<T1>可分配给I<T2>。如果我是反差的话,结果就会恢复。如果我是不变的,那么I<T1>既不能分配给I<T2>
我会创建一个这样的接口:
class IMother {
public:
// This getter return a map which contains a member functer pointer
virtual map<string, void (IMother::*)()> getMap() const = 0;
virtual ~IModule() {};
};
然后,创建一个子级并覆盖getter,以便返回一个只包含Child_1成员函数指针的映射
class Child_1 : public IMother {
private:
map<
给定的是类IPrinterManager及其子类ColorPrinterManager。ColorPrinter是AbstractPrinter的子类。编译中止,并显示消息ColorPrinterManager::print is not a covariant of IPrinterManager::print。如何解决此问题?
class IPrinterManager
{
public:
virtual std::vector<std::shared_ptr<AbstractPrinter>>* print(std::string text) = 0;
好的,我有一个类,它包装了所有的WinAPI控件,使它们像Java/C#/.Net控件那样操作(是的,我知道已经有这样的库了),看起来像这样:
class Control
{
public:
//Bunch of other stuff..
virtual HWND GetHandle() const;
};
和一个派生类,如下所示:
class MenuBar: public Control
{
public:
//Bunch of other stuff..
virtual HMENU GetHandl
class Ancestor{};
class Descendant : public Ancestor{};
class Base
{
public:
Ancestor foo(void);
};
class Derived : public Base
{
public:
// Do not redefine foo as : Descendant foo(void);
};
我想以这样一种方式编写Deriveds foo,当为派生对象调用它时,它将返回Descendant.I。我知道使用协变返回类型可以很容易地做到这一点。但是如果我不能使用这个功能呢?我如何在上面的代码中模拟这
我通过继承创建了两个简单的类,并在子类中添加了一个虚函数和覆盖。
class Parent
{
public:
virtual Parent foo();
};
class Child : public Parent
{
public:
Child foo() override;
};
在本例中,我的被覆盖函数得到一个错误:error C2555: 'Child::foo': overriding virtual function return type differs and is not covariant from 'Parent::foo
我正在查看action book中的scala,它有以下代码
sealed abstract class Maybe[+A] {
def isEmpty: Boolean
def get: A
def getOrElse[B >: A](default: B): B = {
if(isEmpty) default else get
}
}
final case class Just[A](value: A) extends Maybe[A] {
def isEmpty = false
def get = value
#include <iostream>
template <typename T>
class A {};
template <typename T>
class B : public A<T> {};
class C
{
virtual A<int> func() = 0;
};
class D : public C
{
virtual B<int> func() override
{
return B<int>{};
}
};
这里,B继承自A,两个返
我将尝试缩短此代码示例:
public interface IThing
{
//... Stuff
}
public class Thing1 : IThing
{
}
public class Thing2 : IThing
{
}
public interface IThingView<out T>
{
ICollection<T> ViewAll();
}
public class ThingView<T> : IThingView<T>
{
ICollection<T> ViewAl
我有以下代码,它编译没有任何错误或警告。
#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{
TypeX func( int i ){return typex;} // builtin function
};
class Derived:Base{
TypeY func(int i){return typey;}
}
我对这个所谓的协变返回类型的理解正确吗?这个词真的让我很困惑。
如你所知,。我需要帮助将其应用于一组具有自动实现属性的类。
我有两个表示金融银行帐户和交易的抽象类。我将它们抽象,因为我将从不同的数据源提取数据,虽然主要属性在所有源中都是通用的,但每个源可能有我想要保留的附加字段。两个类别之间存在一对多关系(一个帐户有多个事务,而一个事务只属于一个帐户)。
public abstract class BankAccount
{
public string Name { get; set; }
public IList<Transaction> Transactions { get; set; } = new List<Tr
在我的应用程序中,我使用不同的web来获取汽车信息。对于我已经实现的服务,我实现了ICarService。由于所有这些Api返回的汽车数据都不一样,我已经实现了ICar接口,因此每个服务都可以返回自己类型的汽车,但在我的应用程序中,我可以使用“通用”ICar。
以下是我的实现:
// Car Model
public interface ICar
{
string Color { get; }
}
public class CarApiA : ICar
{
public int car_color { get; set; }
public Color
{
我对朱莉娅很陌生,这让我发疯了:
type MyType{T<:Number}
x::T
y::T
end
Float64 <: Number # this is true
MyType{Float64} <: MyType{Number} #this is for some reason false
当然,如果我创建两种具体类型,一种是使用抽象类型作为参数,另一种是使用用于第一次派生的抽象类型的子类型,那么使用具体类型导出的类型将是使用抽象类型派生的类型的子类型。
那句话花了我一段时间才写好。希望它是可以理解的。
我使用List.Contains来判断变量是否在列表中,但是它不断地返回它不是的时候。
我已经查找了,并注意到我必须继承IEquatable并实现自己的.Equals方法。实际的类是从另一个类继承的,因此我在基类.Equals 中编写了方法。
下面是“Actividad”类的代码:
abstract public class Actividad:IEquatable<Actividad> {
protected int codigo;
[...]
public bool Equals(Actividad otra)
{
ret