C++万能数据结构，适当扩展可以自由组合表达几乎所有的数据类型

我会带着你远行 2022-10-16 09:52 157阅读 0赞

// Example program  
\#include < iostream >  
\#include < complex >  
\#include < string >  
\#include < list >  
\#include < vector >  
\#include < sstream >  
using namespace std;

class var  
\{  
public:  
union \_DATA  
\{  
int i;  
bool b;  
double d;  
char c;  
void\* pData; // string\*.  
// complex\*,  
// vector < var\* > \*  
// list < var\* > \*

//void\* vector < var\* > \*pVectorData;  
//void\* list < var\* > \*pListData;  
\};  
enum \_DATA\_TYPE  
\{  
TYPE\_NULL = 0,

TYPE\_INT = 1,  
TYPE\_DOUBLE,  
TYPE\_CHAR,  
TYPE\_STRING,  
TYPE\_COMPLEX,

TYPE\_VECTOR\_DATA = 11,  
TYPE\_LIST\_DATA = 12,

TYPE\_FOLLOW\_RIGHT = 21, //主要用于运算，表示结果取决于右操作数  
TYPE\_FOLLOW\_LEFT = 22, //主要用于运算，表示结果取决于左操作数

TYPE\_ANY = 31, // 表示任意数据类型，为了简化运算表的！  
TYPE\_EXCEPTION = 32, //无法计算，抛出异常！！！  
\};  
enum \_OPERATOR  
\{  
  
OPERATOR\_ADD = 0,  
OPERATOR\_SUB = 1,  
OPERATOR\_MUL = 2,  
OPERATOR\_DIV = 3,

OPERATOR\_POW = 11,  
OPERATOR\_ADD\_PRE = 12,  
OPERATOR\_ADD\_AFTER = 13,

\};  
public:  
var() :\_type(TYPE\_NULL)  
\{  
\}  
~var()  
\{  
clear();  
//cout \#\# endl\#\#"------- delete object ----------" \#\# endl;  
\}  
public:

var(const int i1)  
\{  
\_data.i = i1;  
\_type = TYPE\_INT;  
\}  
var(const double d1)  
\{  
\_data.d = d1;  
\_type = TYPE\_DOUBLE;  
\}  
var(const complex < double > & c1)  
\{  
\_data.pData = new complex < double > (c1);  
\_type = TYPE\_COMPLEX;  
\}  
var(const string& s)  
\{  
\_data.pData = new string(s);  
\_type = TYPE\_STRING;  
\}  
var(const char\* s1)  
\{  
\_data.pData = new string(s1);  
\_type = TYPE\_STRING;  
\}  
var(const var& v1)  
\{  
\_type = v1.\_type;

switch (v1.\_type)  
\{  
case TYPE\_NULL:  
return;  
case TYPE\_INT:  
\_data.i = v1.\_data.i;  
return;  
case TYPE\_DOUBLE:  
\_data.d = v1.\_data.d;  
return;  
  
case TYPE\_STRING:  
\_data.pData = new string(\*(std::string\*)v1.\_data.pData);  
return;

case TYPE\_COMPLEX: //  
\_data.pData = new complex < double > (\*(complex < double > \*)v1.\_data.pData);  
return;  
break;

case TYPE\_VECTOR\_DATA:  
\{  
\_data.pData = new vector < var\* > ();  
vector < var\* > \* pv = (vector < var\* > \*)\_data.pData;  
for (auto& dat : \*(vector < var\* > \*)v1.\_data.pData)  
\{  
var\* pvar = new var(\*dat);  
pv- > push\_back(pvar);  
\}  
return;  
\}  
break;

case TYPE\_LIST\_DATA:  
\{  
\_data.pData = new list < var\* > ();  
list < var\* > \* pl = (list < var\* > \*)\_data.pData;  
for (auto& dat : \*(list < var\* > \*)v1.\_data.pData)  
\{  
var\* pvar = new var(\*dat);  
pl- > push\_back(pvar);  
\}  
return;  
\}  
break;  
\}  
\}  
template < class T >  
var(const list < T > & ls)  
\{  
\_data.pData = new list < var\* > ();  
\_type = TYPE\_LIST\_DATA;  
list < var\* > \* pl = (list < var\* > \*)\_data.pData;  
for (auto& dat :ls)  
\{  
var\* pvar = new var(dat);  
pl- > push\_back(pvar);  
\}  
\}  
template < class T >  
var(const vector < T > & v)  
\{  
\_data.pData = new vector < var\* > ();  
\_type = TYPE\_VECTOR\_DATA;  
vector < var\* > \* pl = (vector < var\* > \*)\_data.pData;  
for (auto& dat : v)  
\{  
var\* pvar = new var(dat);  
pl- > push\_back(pvar);  
\}  
\}  
// 下面这个用于直接从序列构造，如 var \_data(\{1,2,3\}); \_data = \{"hello","world"\};  
template < class T >  
var(const initializer\_list < T > & ld) :\_type(TYPE\_NULL)  
\{  
for (auto& dat : ld)  
\{  
push\_back(var(dat));  
\}  
\}  
template < class T >  
var& operator=(const initializer\_list < T > & ld)  
\{  
clear();  
for (auto& dat : ld)  
\{  
push\_back(var(dat));  
\}  
return \*this;  
\}

public:  
var & operator=(const int i1)  
\{  
clear();  
\_data.i = i1;  
\_type = TYPE\_INT;  
return \*this;  
\}  
var & operator=(const double d1)  
\{  
clear();  
\_data.d = d1;  
\_type = TYPE\_DOUBLE;  
return \*this;  
\}

var & operator=(const string& s1)  
\{  
clear();  
\_data.pData = new string(s1);  
\_type = TYPE\_STRING;  
return \*this;  
\}  
var & operator=(const char\* s1)  
\{  
clear();  
\_data.pData = new string(s1);  
\_type = TYPE\_STRING;  
return \*this;  
\}

var & operator=(const var&v1)  
\{  
if (this == &v1)  
return \*this;

clear();  
\_type = v1.\_type;

switch (v1.\_type)  
\{  
case TYPE\_NULL:  
return \*this;

case TYPE\_INT:  
\_data.i = v1.\_data.i;  
return \*this;

case TYPE\_DOUBLE:  
\_data.d = v1.\_data.d;  
return \*this;

case TYPE\_STRING:  
\_data.pData = new string(\*(std::string\*)v1.\_data.pData);  
return \*this;

case TYPE\_COMPLEX: //  
\_data.pData = new complex < double > (\*(complex < double > \*)v1.\_data.pData);  
return \*this;  
break;

return \*this;  
\}  
template < class T >  
var& operator =(const list < T > & ls)  
\{  
clear();  
\_data.pData = new list < var\* > ();  
\_type = TYPE\_LIST\_DATA;  
list < var\* > \* pl = (list < var\* > \*)\_data.pData;  
for (auto& dat : ls)  
\{  
var\* pvar = new var(dat);  
pl- > push\_back(pvar);  
\}

return \*this;  
\}  
template < class T >  
var& operator = (const vector < T > & v)  
\{  
clear();

\_data.pData = new vector < var\* > ();  
\_type = TYPE\_VECTOR\_DATA;  
vector < var\* > \* pl = (vector < var\* > \*)\_data.pData;  
for (auto& dat : v)  
\{  
var\* pvar = new var(dat);  
pl- > push\_back(pvar);  
\}

return \*this;  
\}  
public:  
void push\_back(const var& v)  
\{  
//如果当前对象非复合数据类型，生成链表  
switch (\_type)  
\{  
// 如果原来为空，变成加入对象  
case TYPE\_NULL:  
(\*this) = v;  
break;  
  
//如果简单数据类型,自动变成list类型！！！  
case TYPE\_INT:  
case TYPE\_DOUBLE:  
\{  
var\* ptemp = new var(\*this);  
\_data.pData = new vector < var\* > ();  
\_type = TYPE\_VECTOR\_DATA;  
vector < var\* > \* pl = (vector < var\* > \*)\_data.pData;  
pl- > push\_back(ptemp);  
pl- > push\_back(new var(v));  
\}  
break;

case TYPE\_STRING:  
\{  
string\* ptemp = (string\*)\_data.pData;

\_data.pData = new vector < var\* > ();  
\_type = TYPE\_VECTOR\_DATA;  
vector < var\* > \* pl = (vector < var\* > \*)\_data.pData;  
  
var\* pvar = new var();  
pvar- > \_type = TYPE\_STRING;  
pvar- > \_data.pData = ptemp;

pl- > push\_back(pvar);  
pl- > push\_back(new var(v));  
\}  
break;  
case TYPE\_COMPLEX:  
\{  
complex < double > \* ptemp = (complex < double > \*)\_data.pData;

\_data.pData = new vector < var\* > ();  
\_type = TYPE\_VECTOR\_DATA;  
vector < var\* > \* pl = (vector < var\* > \*)\_data.pData;

var\* pvar = new var();  
pvar- > \_type = TYPE\_COMPLEX;  
pvar- > \_data.pData = ptemp;

pl- > push\_back(pvar);  
pl- > push\_back(new var(v));  
\}  
break;

case TYPE\_LIST\_DATA:  
\{  
list < var\* > \* pl = (list < var\* > \*)\_data.pData;  
pl- > push\_back(new var(v));  
\}  
break;  
case TYPE\_VECTOR\_DATA:  
\{  
vector < var\* > \* pv = (vector < var\* > \*)\_data.pData;  
pv- > push\_back(new var(v));  
\}  
break;  
  
\}  
//如果当前对象已经是复合数据类型，保持原类型不变，增加新数据  
\}  
void push\_front(const var& v)  
\{  
//如果当前对象非复合数据类型，生成链表  
switch (\_type)  
\{  
// 如果原来为空，变成加入对象  
case TYPE\_NULL:  
(\*this) = v;  
break;

//如果简单数据类型,自动变成list类型！！！  
case TYPE\_INT:  
case TYPE\_DOUBLE:  
case TYPE\_STRING:  
case TYPE\_COMPLEX:  
\{  
var\* ptemp = new var(\*this);  
\_data.pData = new vector < var\* > ();  
\_type = TYPE\_VECTOR\_DATA;  
vector < var\* > & v1 = \*(vector < var\* > \*)\_data.pData;  
v1\[0\] = new var(v);  
v1\[1\] = ptemp;  
\}  
break;

case TYPE\_LIST\_DATA:  
\{  
list < var\* > \* pl = (list < var\* > \*)\_data.pData;  
pl- > push\_front(new var(v));  
\}  
break;  
case TYPE\_VECTOR\_DATA:  
\{  
vector < var\* > & v1 = \*(vector < var\* > \*)\_data.pData;  
v1.push\_back(0);  
int size = v1.size();  
for (int i = size - 1; i > 0; --i)  
v1\[i\] = v1\[i - 1\];  
v1\[0\] = new var(v);  
\}  
break;

\}  
//如果当前对象已经是复合数据类型，保持原类型不变，增加新数据  
\}

public:  
friend ostream& operator \#\#(ostream& os, const var& v);  
var& operator\[\](const int pos)  
\{  
if (\_type == TYPE\_VECTOR\_DATA)  
\{  
return \*(\*(vector < var\* > \*)\_data.pData)\[pos\];  
\}  
else if (\_type == TYPE\_LIST\_DATA)  
\{  
list < var\* > \* pl = (list < var\* > \*)\_data.pData;  
//return \*(pl- > begin() + i);  
auto it = pl- > begin();  
for (int i = 0; i < pos; ++i)  
\{  
\++it;  
\}  
return \*(\*it);  
\}  
else if (pos == 0)  
\{  
return \*this;  
\}  
else  
\{  
throw string("error, not an array!");  
\}  
  
\}  
int size() const  
\{  
switch (\_type)  
\{  
case TYPE\_NULL:  
return 0;

//如果简单数据类型,自动变成list类型！！！  
case TYPE\_INT:  
case TYPE\_DOUBLE:  
case TYPE\_STRING:  
case TYPE\_COMPLEX:  
return 1;

case TYPE\_VECTOR\_DATA:  
return ((vector < var\* > \*)(\_data.pData))- > size();  
break;  
case TYPE\_LIST\_DATA:  
return ((list < var\* > \*)(\_data.pData))- > size();  
break;

default:  
return 0;  
\}

\}  
string tostring() const  
\{  
stringstream temp;  
temp \#\# (\*this);  
return temp.str();  
\}  
public:  
void clear()  
\{  
switch (\_type)  
\{  
case TYPE\_NULL:  
break;

case TYPE\_STRING:  
delete (string\*)(\_data.pData);  
break;

case TYPE\_COMPLEX: //  
delete (complex < double > \*)(\_data.pData);  
break;

case TYPE\_VECTOR\_DATA:  
for (auto& dat : \*(vector < var\* > \*)\_data.pData)  
\{  
delete dat;  
dat = NULL;  
\}  
delete (vector < var\* > \*)(\_data.pData);  
break;  
case TYPE\_LIST\_DATA:  
for (auto& dat : \*(list < var\* > \*)\_data.pData)  
\{  
delete dat;  
dat = NULL;  
\}  
delete (list < var\* > \*)(\_data.pData);  
break;  
\}

\_data.pData = NULL;  
\_type = TYPE\_NULL;  
\}  
public:  
var& operator +=(const var& v1);  
var& operator -=(const var& v1);  
var& operator \*=(const var& v1);  
var& operator /=(const var& v1);

var& operator ^=(const var& v1);

public:  
var::\_DATA\_TYPE type() const  
\{  
return \_type;  
\}  
public:  
var::\_DATA\_TYPE find\_result\_type(const var::\_OPERATOR op,  
const var::\_DATA\_TYPE left,  
const var::\_DATA\_TYPE right)  
\{  
// I will try to use another mechnism!!!  
  
\}

protected:  
\_DATA \_data;  
\_DATA\_TYPE \_type;  
\};

var& var::operator +=(const var& v1)  
\{  
switch (\_type)  
\{  
case TYPE\_LIST\_DATA:  
if (v1.\_type == TYPE\_LIST\_DATA) // if both are lists, then combine them  
\{  
list < var\* > & l1 = \*(list < var\* > \*)v1.\_data.pData;  
for (auto& dat : l1)  
\{  
push\_back(\*dat);  
\}  
\}  
else // else push\_back the right operand  
\{  
this- > push\_back(v1);  
\}  
return \*this;  
break;

case TYPE\_VECTOR\_DATA:  
if (v1.\_type == TYPE\_VECTOR\_DATA)  
\{  
vector < var\* > & vv = \*(vector < var\* > \*)v1.\_data.pData;  
for (auto& dat : vv)  
\{  
push\_back(\*dat);  
\}  
\}  
else  
\{  
this- > push\_back(v1);  
\}  
return \*this;

case TYPE\_NULL:  
(\*this) = v1;  
return \*this;

case TYPE\_INT:  
if (v1.\_type == TYPE\_INT)  
\{  
\_data.i += v1.\_data.i;  
return \*this;  
\}  
else if (v1.\_type == TYPE\_DOUBLE)  
\{  
\_type = TYPE\_DOUBLE;  
\_data.d = \_data.i + v1.\_data.d;  
return \*this;  
\}  
else if (v1.\_type == TYPE\_COMPLEX)  
\{  
\_type = TYPE\_COMPLEX;  
\_data.c = \_data.i + v1.\_data.c;  
return \*this;  
\}  
else if (v1.\_type == TYPE\_STRING)  
\{  
\_data.pData = new string(tostring() + \*(string\*)(v1.\_data.pData));  
\_type = TYPE\_STRING;  
return \*this;  
\}  
else if ((v1.\_type == TYPE\_LIST\_DATA) || (v1.\_type == TYPE\_VECTOR\_DATA))  
\{  
int temp = \_data.i;  
clear();  
(\*this) = v1;  
push\_front(var(temp));  
return \*this;  
\}  
else  
\{  
throw "Error, data type NOT matched!!!";  
\}  
break;  
case TYPE\_DOUBLE:  
if (v1.\_type == TYPE\_INT)  
\{  
\_data.d += v1.\_data.i;  
return \*this;  
\}  
else if (v1.\_type == TYPE\_DOUBLE)  
\{  
\_data.d += v1.\_data.d;  
return \*this;  
\}  
else if (v1.\_type == TYPE\_COMPLEX)  
\{  
\_type = TYPE\_COMPLEX;  
\_data.pData = new complex < double > (\_data.d + \*(complex < double > \*)v1.\_data.pData);  
return \*this;  
\}  
else if (v1.\_type == TYPE\_STRING)  
\{  
\_data.pData = new string(tostring() + \*(string\*)(v1.\_data.pData));  
\_type = TYPE\_STRING;  
return \*this;  
\}  
else if ((v1.\_type == TYPE\_LIST\_DATA) || (v1.\_type == TYPE\_VECTOR\_DATA))  
\{  
int temp = \_data.d;  
clear();  
(\*this) = v1;  
push\_front(var(temp));  
return \*this;  
\}  
else  
\{  
throw "Error, data type NOT matched!!!";