我正在编写一个用于模拟分布式传感器群的python平台.这个想法是最终用户可以编写一个由SensorNode行为(通信,日志记录等)组成的自定义节点,以及实现许多不同的传感器.
下面的例子简要说明了这个概念.
#prewritten
class Sensor(object):
def __init__(self):
print "Hello from Sensor"
#...
#prewritten
class PositionSensor(Sensor):
def __init__(self):
print "Hello from Position"
Sensor.__init__(self)
#...
#prewritten
class BearingSensor(Sensor):
def __init__(self):
print "Hello from Bearing"
Sensor.__init__(self)
#...
#prewritten
class SensorNode(object):
def __init__(self):
print "Hello from SensorNode"
#...
#USER WRITTEN
class MySensorNode(SensorNode,BearingSensor,PositionSensor):
def CustomMethod(self):
LogData={'Position':position(), 'Bearing':bearing()} #position() from PositionSensor, bearing() from BearingSensor
Log(LogData) #Log() from SensorNode
首先概述我想要实现的目标:我正在编写一个模拟器来模拟群体智能算法,特别关注移动传感器网络.这些网络由许多小型机器人组成,这些小型机器人传递单个传感器数据以构建复杂的环境感官图.
该项目的基本目标是开发一个模拟平台,为传感器提供抽象接口,使得相同的用户实现功能可以直接移植到运行嵌入式Linux的机器人群中.由于机器人实现是目标,我需要设计软件节点的行为相同,并且只能访问物理节点可能具有的信息.
作为模拟引擎的一部分,我将提供一组建模不同类型传感器和不同类型传感器节点的类.我希望从用户那里抽象出所有这些复杂性,以便所有用户必须做的是定义节点上存在哪些传感器,以及实现什么类型的传感器节点(移动,固定位置).
我最初的想法是每个传感器都会提供一个read()方法,它会返回相关的值,但是在阅读了问题的答案之后,我看到也许更具描述性的方法名称会有所帮助(.distance(),. position( ),. bearing()等).
我最初想要为传感器使用单独的类(具有共同的祖先),以便更技术的用户可以轻松地扩展其中一个现有类,以便在需要时创建新的传感器.例如:
Sensor
|
DistanceSensor(designed for 360 degree scan range)
| …假设我有一个实现两个或更多COM接口的类:
class CMyClass : public IInterface1, public IInterface2 {
};
几乎我看到的每个文档都表明,当我为IUnknown实现QueryInterface()时,我明确地将此指针向上转换为其中一个接口:
if( iid == __uuidof( IUnknown ) ) {
*ppv = static_cast<IInterface1>( this );
//call Addref(), return S_OK
}
问题是为什么我不能复制这个？
if( iid == __uuidof( IUnknown ) ) {
*ppv = this;
//call Addref(), return S_OK
}
文档通常说如果我执行后者,我将违反对同一对象上的QueryInterface()的任何调用必须返回完全相同的值的要求.
我不太明白.难道他们的意思是,如果我QI()用于IInterface2和调用QueryInterface()通过该指针C++将通过此略有不同,如果我QI()用于IInterface2因为C++每次都会使这点到子对象？
我有一个基类'Base',这是一个纯虚拟类:
class Base {
public:
virtual void A() = 0;
virtual void B() = 0;
virtual ~Base() { } // Eclipse complains that a class with virtual members must have virtual destructor
};
我还有另外两个类,其中一个实现了A(),另一个实现了B():
class DerivedA : public virtual Base
{
public:
virtual void A() {
printf("Hello from A");
}
};
class DerivedB : public virtual Base
{
public:
virtual void B() {
printf("Hello from B");
}
};
声明中的虚拟关键字应解决钻石问题.
现在我想将这两个类组合成另一个类,以便实现A()和B(),如下所示:
class DerivedC: public DerivedA, public DerivedB {
// Now DerivedA …除了教科书示例 - 在现实世界中 - 在C++中使用多重继承(其中多个基类不是纯接口)是否有意义？
(事先原谅noob问题)
我有4个班:
class Person {};
class Student : public Person {};
class Employee : public Person {};
class StudentEmployee : public Student, public Employee {};
基本上Person是基类,其直接由两个子类Student和Employee.StudentEmployee使用多重继承来子类化Student和Employee.
Person pat = Person("Pat");
Student sam = Student("Sam");
Employee em = Employee("Emily");
StudentEmployee sen = StudentEmployee("Sienna");
Person ppl[3] = {pat, sam, em};
//compile time error: ambiguous base class
//Person ppl[4] = {pat, sam, em, sen};
当我使用Person基类的数组时,我可以将Person它的所有子类放在这个数组中.除了StudentEmployee,给出基础模糊的原因. …
我有一个没有虚拟基类的多继承场景,如下所示:
Ta Tb
| |
B C
\ /
A
Ta和Tb是两个不同的模板类,它们都声明了一个名为f()的虚函数.我想覆盖A范围中的两个函数,因为我必须在这些方法中与B和C数据进行交互.但我不知道该怎么做.
class Tb {
protected:
virtual void f() {};
public:
void call() {
this->f();
};
};
class Tc {
protected:
virtual void f() {};
public:
void call() {
this->f();
};
};
class B : public Tb {
public:
void doSomething() {};
};
class C : public Tc {
private:
int c;
public:
void inc() { c++; };
};
class A : public B, public C {
protected:
void f() { …#include <iostream>
struct B1
{
virtual void method()=0;
virtual ~B1(){}
};
struct B2
{
virtual void method()=0;
virtual ~B2(){}
};
struct D: B1, B2
{
virtual void method()
{
std::cout << "D::method\n";
};
};
int main(int argc,char *argv[])
{
D d;
B1 &b1=d;
B2 &b2=d;
b1.method();
b2.method();
return 0;
}
注意,B1和B2不共享通用接口.
这合法吗？如果是 - 在哪个标准？C++ 98/03/11？
msvc和gcc都编译好了.
以前我想过,我必须使用一些通用接口来处理这种情况(可能的虚拟继承).
这种情况有什么特别的名字吗？
请问它的工作原理如何？也许一些ISO参考？
是否有可能有一些抽象接口的部分实现,然后通过使用多个继承将这些部分实现收集到一个具体的类中？
我有以下示例代码:
#include <iostream>
struct Base
{
virtual void F1() = 0;
virtual void F2() = 0;
};
struct D1 : Base
{
void F1() override { std::cout << __func__ << std::endl; }
};
struct D2 : Base
{
void F2() override { std::cout << __func__ << std::endl; }
};
// collection of the two partial implementations to form the concrete implementation
struct Deriv : D1, D2
{
using D1::F1; // I …我经常想要创建一个对象列表,其中每个对象必须实现许多接口.例如,我想做类似以下的事情:
List<T> where T : IConvertible, IComparable _myList;
我考虑的另一个选项是创建一个实现这两个接口的第三个接口,以便实现这两个接口的任何对象本身都实现了我的.
public interface IConvertibleAndComparable
: IConvertible, IComparable { }
List<IConvertibleAndComparable> _myList;
有了这个,我就能够添加同时实现任何物体IConvertible和IComparable,包括double和int,以及我自己的对象.IConvertibleAndComparable不需要显式实现,因为它不会在继承中的接口之外添加任何新功能.
我知道第一个片段是非法的,第二个是合法的,不符合我的要求.是否有可能实现我想做的事情？如果没有,这些中的任何一个都会成为未来C#功能的候选者吗？
(注意:这将是空接口的合法应用程序.)
编辑
在更一般的意义上,我想执行以下操作之一:
private MyGenericClass<T> where T : IA, IB, ... _myClass;
我可以在哪里声明T我需要的所有限制,或者
public interface IMyCombinedInterface : IA, IB, ... {}
private MyGenericClass<IMyCombinedInterface> _myClass;
任何实现IA,IB以及...固有(或隐式)实现的类型IMyCombinedInterface(仅当IMyCombinedInterface未明确声明新功能时).
在英语中,同形异义词对是两个具有相同拼写但含义不同的单词.
在软件工程中,一对同形方法是两种具有相同名称但要求不同的方法.让我们看一个人为的例子,让问题尽可能清晰:
interface I1 {
/** return 1 */
int f()
}
interface I2 {
/** return 2*/
int f()
}
interface I12 extends I1, I2 {}
我该如何实施I12？C#有办法做到这一点,但Java没有.所以唯一的方法是破解.怎样才能最可靠地使用反射/字节码技巧/等(也就是说它不一定是一个完美的解决方案,我只想要一个效果最好的解决方案)？
请注意,我无法合法反向工程的一些现有的闭源大量遗留代码需要一个类型参数,I12并将I12两者都委托给I1作为参数的代码和作为参数的代码I2.所以基本上我需要让它的一个实例I12知道什么时候它应该起作用I1,什么时候它应该起作用I2,我相信可以通过在直接调用者的运行时查看字节码来完成.我们可以假设调用者没有使用反射,因为这是简单的代码.问题是作者I12没想到Java会f从两个接口合并,所以现在我必须想出最好的解决问题的方法.没有什么叫I12.f(显然如果作者写了一些实际调用的代码I12.f,他会在出售之前注意到这个问题).
请注意,我实际上是在寻找这个问题的答案,而不是如何重构我无法改变的代码.我正在寻找可行的最佳启发式或者如果存在的话,可以找到精确的解决方案.请参阅Gray的答案以获得有效示例(我确信有更强大的解决方案).
这是一个具体的例子,说明两个接口内的单应方法问题是如何发生的.这是另一个具体的例子:
我有以下6个简单的类/接口.它类似于剧院周围的商业和在其中表演的艺术家.为了简单起见,我们假设它们都是由不同的人创建的.
Set 代表一组,如集合论:
interface Set {
/** Complements this set,
i.e: all elements in the set …c++ ×7
inheritance ×3
oop ×2
c# ×1
class ×1
com ×1
constructor ×1
hierarchy ×1
interface ×1
java ×1
overriding ×1
polymorphism ×1
python ×1
virtual ×1
visual-c++ ×1