给定一个C++函数f(X x),其中X是X类型的变量,Y是Y类型的变量,那么C++编译器将对y执行哪些自动/隐式转换,从而使语句"f(y);“是合法代码(没有错误,没有警告)?
例如:
将派生&传递给采用Base的函数&- ok传递Base& to function Derived& - not ok,但不将int强制转换传递给采用long - ok的函数- ok,创建一个临时的长传递int& to函数采用long& - NOT ok,引用临时
请注意,与类相比,内置类型有一些奇怪之处:可以将派生类型传递给接受Base的函数(尽管它会被切
假设我们有以下类:
from __future__ import annotations
class BaseSwallow:
# Can't get the ref to `BaseSwallow` at runtime
DerivedSwallow = NewType('DerivedSwallow', BaseSwallow)
def carry_with(self, swallow: DerivedSwallow):
self.carry()
swallow.carry()
def carr
假设我有两个抽象类,名为“颜色和动物”
我可以使用工厂模式在运行时创建从Color派生的类Green/Red/Blue和类Dog/Cat/Pig。
然后,我有一个模板类混合:
template<class A, class B>
class Hybrid
: public A, public B
{}
我想要做的是实例化模板类混合,并在运行时创建派生类,如Green和Dog。
这个是可能的吗?或者还有其他方法来实现类似的功能呢?
我有一个泛型属性,用于表示物理地址列表: public T PhysicalAddressList
{
get => GetPhysicalAddressListValue<T>(_physicalAddressList);
set => _physicalAddressList = SetPhysicalAddressListValue<T>(value);
} 我为get和set使用了一个字段。但是,在这个基类的整个生命周期中,我需要在字段上运行一些更改。因此,字段_physicalAddressList被显式声明为: List<
如何将对象列表向下转换,使列表中的每个对象都向下转换为派生类的对象?
这就是这个场景。
我有一个基类,它有一个基项的List,以及从它继承的两个类:
public class BaseClass
{
public List<BaseItem> items;
protected BaseClass()
{
// some code to build list of items
}
}
public class DerivedClass : BaseClass
{
public DerivedClass : base() {}
}
其他语言中有一个"is“操作符,它允许这样做,我如何在C++中模拟它,并且它可以在运行时完成呢?
比如说,
class A {
public:
// virtual methods..
};
class B : public A {};
class C: public A {};
A* x;
template<typename T>
bool foo(A* par); // returns true if par is of type T
int main() {
A* b = new B();
A* c = new C();
x = c;
if(foo&l
我有以下声明。
val a: Any = Array("1", "2", "3")
a match {
case p: Array[Int] => println("int")
case l: Array[String] => println("string")
}
val b: Any = List(1, 2, 3)
b match {
case l: List[String] => println("string")
case p: List[Int] =&g
我如何知道对函数的调用是在编译时还是从任何类的运行时解析的?
例如,在下面的示例中,当show()被调用时,从派生类中调用,它会在运行时被解析吗?
#include <iostream>
using std::ostream;
class Base
{
public:
virtual void show() {
show(); //Call derived class 'show()'
}
};
class Derived : public Base {
public:
void show() {
码
struct A { }; // virtual details there, but left out
struct B { }; // virtual details there, but left out
struct C : A, B { }; // virtual details there, but left out
C c;
B& b = c;
A& a = dynamic_cast<A&>( b ); // will this cast succeed at run-time?
请注意,为
我希望我的代码是可扩展的,在运行时我可以创建对象。
例如,假设我有一个Grocery类,它有一个水果数组,我想用从水果派生的对象填充这个水果数组。
class Fruit{
};
class Grocery{
std::vector<Fruit*> m_fruits;
};
class Apple: Fruit{
};
class Pineapple: Fruit{
};
现在,在运行时,我希望我的杂货类向量m_fruits由苹果和凤梨的类对象填充。所以有没有可能在某种程度上。
如果我将来添加另一个水果作为草莓,它的对象将被动态创建并添加到Grocery的向量