我需要在一个向量中存储多种类型的模板类.
例如,对于:
template <typename T>
class templateClass{
bool someFunction();
};
我需要一个存储所有的向量:
templateClass<int> t1;
templateClass<char> t2;
templateClass<std::string> t3;
etc
据我所知这是不可能的,如果有人可以说怎么样？
如果不可能有人解释如何进行以下工作？
作为一种解决方法,我尝试使用基本的非模板类并从中继承模板类.
class templateInterface{
virtual bool someFunction() = 0;
};
template <typename T>
class templateClass : public templateInterface{
bool someFunction();
};
然后我创建了一个向量来存储基础"templateInterface"类:
std::vector<templateInterface> v;
templateClass<int> t;
v.push_back(t);
这产生了以下错误:
error: cannot allocate an object of abstract type 'templateInterface'
note: because the following virtual functions are pure within 'templateInterface'
note: virtual bool templateInterface::someFunction()
为了解决这个错误,我在templateInterface中使函数不是一个纯虚拟的,通过提供一个函数体,这个编译但是在调用函数时不使用overide,而是在虚函数中使用body.
例如:
class templateInterface{
virtual bool someFunction() {return true;}
}; …如果你有一个带有静态变量的模板类,有没有办法让变量在所有类的类中相同,而不是每个类都相同？
目前我的代码是这样的:
template <typename T> class templateClass{
public:
static int numberAlive;
templateClass(){ this->numberAlive++; }
~templateClass(){ this->numberAlive--; }
};
template <typename T> int templateClass<T>::numberAlive = 0;
主要:
templateClass<int> t1;
templateClass<int> t2;
templateClass<bool> t3;
cout << "T1: " << t1.numberAlive << endl;
cout << "T2: " << t2.numberAlive << endl;
cout << "T3: " << t3.numberAlive << endl;
这输出:
T1: 2
T2: 2
T3: 1
所期望的行为在哪里:
T1: 3
T2: 3
T3: 3
我想我可以使用某种类型的全局int来实现它,任何类型的此类递增和递减,但这看起来不合逻辑,或者面向对象
谢谢任何可以帮助我实现这一点的人.
我见过/使用过的许多库都有typedef来提供可移植的,固定大小的变量,例如int8,uint8,int16,uint16等,无论平台如何,它们都是正确的大小(而c ++ 11本身就带有标题stdint. H)
最近在我正在编写的小型库中使用二进制文件i/o后,我可以看到以这种方式使用typedef以确保代码可移植的好处.
但是,如果我要输入"namespace :: uint32"而不是使用内置基本类型的麻烦,我也可以让替换尽可能有用.因此我正在考虑使用类而不是简单的typedef.
这些包装类将实现所有普通运算符,因此可以与基本类型互换使用.
例如:
int x = 0;
//do stuff
可能成为
class intWrapper {
//whatever
};
intWrapper = 0;
//do stuff
无需修改"// do stuff"中的任何代码
我正在考虑这种方法而不仅仅是typedef的原因是我已经拥有对基本类型进行操作的函数,例如
std::string numberToString(double toConvert);
std::string numberToHexString(double toConvert);
int intToXSignificantPlaces(const int& number,
unsigned char numberOfSignificantPlaces);
bool numbersAreApproximatelyEqual(float tollerance);
//etc....
从语法上讲,执行以下操作会更好(并且更多oop):
intWrapper.toString();
intWrapper.toHexString();
//etc
此外,它允许我实现bigint类(int128等)并使那些和较小的(基于基本类型)使用相同的接口.
最后,每个包装器都可以有一个自己的静态实例,叫做max和min,所以int32 :: max和int32 :: min的语法很好.
但是,在我这样做之前,我想要解决一些问题(因为它主要是语法糖,并且这些类型会被使用,所以通常任何额外的开销都会对性能产生重大影响).
1)当使用someClass.operator +(),someClass.operator-()等而不是int a + int b时,是否有任何额外的函数调用开销？如果是这样,内联运算符+()会消除所有这些开销吗？
2)所有外部函数都需要基本类型,例如glVertex3f(float,float,float)不能简单地传递3个floatWrapper对象,有没有办法自动使编译器将floatWrapper转换为float？如果是这样,是否会产生性能影响？
3)是否有额外的内存开销？我理解(？)具有继承的类具有某种虚拟表指针,因此使用稍多的内存(或者仅仅用于虚函数？),但假设这些包装类不是从子类继承而不是子类,那么任何额外的内存使用使用类而不是基本类型,是吗？
4)这可能导致其他任何问题/性能影响吗？
在C++中是否可以制作某种通用函数指针,指向任何返回指向某种类型的指针并且不带参数的函数？
例如,一种指针可以指向以下两种情况:
int* funcInt(){
int* i = new int;
*i = 5;
return i;
}
char* funcChar(){
char* c = new char;
*c = 'a';
return c;
}
显然以下是有效的:
int* (*funcPointerA)() = funcInt;
char* (*funcPointerB)() = funcChar;
但是有可能做类似下面的事情(它现在给出了编译错误):
void* (*funcPointerC)() = funcInt;
void* (*funcPointerD)() = funcChar;
目前上面的代码给出了以下错误:
error: invalid conversion from 'int* (*)()' to 'void* (*)()'
error: invalid conversion from 'char* (*)()' to 'void* (*)()'
有没有办法将funcPointerA和B转换为C和D？
这是指向两种类型的函数(以及其他在不带参数的情况下返回指向某种类型的指针)的指针可以一起存储在单个向量中.
我需要在类中有一个变量,它是类"ClassA"的实例,但它也实现了接口"InterfaceI".
显然,这可以很容易地为一个或另一个完成:
private ClassA mVariable;
private InterfaceI mVaraible;
但是如何强制对象既扩展了ClassA又实现了InterfaceB？就像是:
private <? extends ClassA & InterfaceI> mVaraible;
是我需要的,但我不知道语法或甚至可能.我还需要一个get和set方法,但这可以用泛型来完成(我想？)
明显的解决方案是
public class ClassB extends ClassA implements InterfaceI{
//whatever here
}
但是,InterfaceI和ClassA都是外部库的一部分,这个库有扩展ClassA和InterfaceI的类,我不能编辑它们以使它们扩展ClassB,因此这个解决方案不起作用.