分配操作员和基本类型的容器 [英] Assigment operator and container of base type

问题描述

以下是我遇到的问题的一个例子。我不明白怎么回事
我可以让编译器看到deri& operator =（const T& rhs）。


我肯定这是一个常见的问题 - 任何建议？

#include< iostream>

#include< vector>


struct base

{

virtual~base（）= 0 {};

};


模板< class T>

结构衍生：公共基础

{

deriv（）：data_（0）{};

deriv（const T& data）：data_（data）{};

deriv& operator =（const T& rhs）{data_ = rhs;返回（* this）; } $ / $
deriv& operator =（const deriv& rhs）

{data_ = rhs.data_;返回（* this）; }

T data_;

};


struct container

{

base& operator []（int i）{return *（data_ [i]）; };

std :: vector< base * data_;

};


void fill_cont（container& data）;


int main（int argc，char * argv []）

{

容器数据;

fill_cont（data）;


std :: cout<< "数据[0] =" << typeid（data [0]）。name（）<< std :: endl;

//输出：data [0] = struct deriv< int>

data [0] = 12445;


std :: cout<< "数据[1] =" << typeid（data [1]）。name（）<< std :: endl;

//输出：data [1] = struct deriv< double>

data [1] = 4.5667;


std :: cout<< "数据[2] =" << typeid（data [2]）。name（）<< std :: endl;

//输出：data [2] = struct deriv< char *>

data [2] =" test" ;;


返回0;

}


void fill_cont（容器和数据）

{

data.data_.push_back（new deriv< int>（））;

data.data_.push_back（new deriv< double>（））;

data.data_.push_back（new deriv< char *>（））;

}


-


Adrian


认为你懂一种语言？发布到comp.lang ...并找出答案！

Below is an example of the problem I am having. I don''t understand how
I can get the compiler to see deriv &operator=(const T &rhs).

I am sure this is a common problem - any suggestions?
#include <iostream>
#include <vector>

struct base
{
virtual ~base()=0 {};
};

template<class T>
struct deriv : public base
{
deriv(): data_(0) {};
deriv(const T &data): data_(data) {};
deriv &operator=(const T &rhs) { data_=rhs; return (*this); }
deriv &operator=(const deriv &rhs)
{ data_=rhs.data_; return (*this); }
T data_;
};

struct container
{
base &operator[](int i) { return *(data_[i]); };
std::vector<base *data_;
};

void fill_cont(container &data);

int main(int argc, char *argv[])
{
container data;
fill_cont(data);

std::cout << "data[0]=" << typeid(data[0]).name() << std::endl;
// output: data[0]=struct deriv<int>
data[0]=12445;

std::cout << "data[1]=" << typeid(data[1]).name() << std::endl;
// output: data[1]=struct deriv<double>
data[1]=4.5667;

std::cout << "data[2]=" << typeid(data[2]).name() << std::endl;
// output: data[2]=struct deriv<char *>
data[2]="test";

return 0;
}

void fill_cont(container &data)
{
data.data_.push_back(new deriv<int>());
data.data_.push_back(new deriv<double>());
data.data_.push_back(new deriv<char *>());
}

--

Adrian

Think you know a language? Post to comp.lang... and find out!

推荐答案

Adrian napsal：

Adrian napsal:

下面是我遇到的问题的一个例子。我不明白怎么回事
我可以让编译器看到deri& operator =（const T& rhs）。


我肯定这是一个常见的问题 - 任何建议？


#include< iostream>

#include< vector>


struct base

{

virtual~base（）= 0 {};

};


模板< class T>

struct deriv：public base

{

deriv（）：data_（0）{};

deriv（const T& data）：data_（data）{};

deriv& operator =（const T& rhs）{data_ = rhs;返回（* this）; } $ / $
deriv& operator =（const deriv& rhs）

{data_ = rhs.data_;返回（* this）; }

T data_;

};


struct container

{

base& operator []（int i）{return *（data_ [i]）; };

std :: vector< base * data_;

};


void fill_cont（container& data）;


int main（int argc，char * argv []）

{

容器数据;

fill_cont（data）;


std :: cout<< "数据[0] =" << typeid（data [0]）。name（）<< std :: endl;

//输出：data [0] = struct deriv< int>

data [0] = 12445;


std :: cout<< "数据[1] =" << typeid（data [1]）。name（）<< std :: endl;

//输出：data [1] = struct deriv< double>

data [1] = 4.5667;


std :: cout<< "数据[2] =" << typeid（data [2]）。name（）<< std :: endl;

//输出：data [2] = struct deriv< char *>

data [2] =" test" ;;


返回0;

}


void fill_cont（容器和数据）

{

data.data_.push_back（new deriv< int>（））;

data.data_.push_back（new deriv< double>（））;

data.data_.push_back（new deriv< char *>（））;

}

Below is an example of the problem I am having. I don''t understand how
I can get the compiler to see deriv &operator=(const T &rhs).

I am sure this is a common problem - any suggestions?
#include <iostream>
#include <vector>

struct base
{
virtual ~base()=0 {};
};

template<class T>
struct deriv : public base
{
deriv(): data_(0) {};
deriv(const T &data): data_(data) {};
deriv &operator=(const T &rhs) { data_=rhs; return (*this); }
deriv &operator=(const deriv &rhs)
{ data_=rhs.data_; return (*this); }
T data_;
};

struct container
{
base &operator[](int i) { return *(data_[i]); };
std::vector<base *data_;
};

void fill_cont(container &data);

int main(int argc, char *argv[])
{
container data;
fill_cont(data);

std::cout << "data[0]=" << typeid(data[0]).name() << std::endl;
// output: data[0]=struct deriv<int>
data[0]=12445;

std::cout << "data[1]=" << typeid(data[1]).name() << std::endl;
// output: data[1]=struct deriv<double>
data[1]=4.5667;

std::cout << "data[2]=" << typeid(data[2]).name() << std::endl;
// output: data[2]=struct deriv<char *>
data[2]="test";

return 0;
}

void fill_cont(container &data)
{
data.data_.push_back(new deriv<int>());
data.data_.push_back(new deriv<double>());
data.data_.push_back(new deriv<char *>());
}

代码很长，但对我来说很奇怪，例如基类中的纯虚拟

析构函数。

The code is quite long, but for me is strange for example pure virtual
destructor in base class.

Adrian napsal：

Adrian napsal:

下面是我遇到的问题的一个例子。我不明白怎么回事
我可以让编译器看到deri& operator =（const T& rhs）。


我肯定这是一个常见的问题 - 任何建议？


#include< iostream>

#include< vector>


struct base

{

virtual~base（）= 0 {};

};


模板< class T>

struct deriv：public base

{

deriv（）：data_（0）{};

deriv（const T& data）：data_（data）{};

deriv& operator =（const T& rhs）{data_ = rhs;返回（* this）; } $ / $
deriv& operator =（const deriv& rhs）

{data_ = rhs.data_;返回（* this）; }

T data_;

};


struct container

{

base& operator []（int i）{return *（data_ [i]）; };

std :: vector< base * data_;

};


void fill_cont（container& data）;


int main（int argc，char * argv []）

{

容器数据;

fill_cont（data）;


std :: cout<< "数据[0] =" << typeid（data [0]）。name（）<< std :: endl;

//输出：data [0] = struct deriv< int>

data [0] = 12445;


std :: cout<< "数据[1] =" << typeid（data [1]）。name（）<< std :: endl;

//输出：data [1] = struct deriv< double>

data [1] = 4.5667;


std :: cout<< "数据[2] =" << typeid（data [2]）。name（）<< std :: endl;

//输出：data [2] = struct deriv< char *>

data [2] =" test" ;;


返回0;

}


void fill_cont（容器和数据）

{

data.data_.push_back（new deriv< int>（））;

data.data_.push_back（new deriv< double>（））;

data.data_.push_back（new deriv< char *>（））;

}


-


Adrian


认为你懂一种语言？发布到comp.lang ...并找出答案！

Below is an example of the problem I am having. I don''t understand how
I can get the compiler to see deriv &operator=(const T &rhs).

I am sure this is a common problem - any suggestions?
#include <iostream>
#include <vector>

struct base
{
virtual ~base()=0 {};
};

template<class T>
struct deriv : public base
{
deriv(): data_(0) {};
deriv(const T &data): data_(data) {};
deriv &operator=(const T &rhs) { data_=rhs; return (*this); }
deriv &operator=(const deriv &rhs)
{ data_=rhs.data_; return (*this); }
T data_;
};

struct container
{
base &operator[](int i) { return *(data_[i]); };
std::vector<base *data_;
};

void fill_cont(container &data);

int main(int argc, char *argv[])
{
container data;
fill_cont(data);

std::cout << "data[0]=" << typeid(data[0]).name() << std::endl;
// output: data[0]=struct deriv<int>
data[0]=12445;

std::cout << "data[1]=" << typeid(data[1]).name() << std::endl;
// output: data[1]=struct deriv<double>
data[1]=4.5667;

std::cout << "data[2]=" << typeid(data[2]).name() << std::endl;
// output: data[2]=struct deriv<char *>
data[2]="test";

return 0;
}

void fill_cont(container &data)
{
data.data_.push_back(new deriv<int>());
data.data_.push_back(new deriv<double>());
data.data_.push_back(new deriv<char *>());
}

--

Adrian

Think you know a language? Post to comp.lang... and find out!

在container :: operator []中，您将返回对base的引用。但是那里

在类''base'中没有赋值运算符，所以编译器看不到它。

In container::operator[] you are returning reference to base. But there
is no assignment operator in class ''base'', so compiler cannot see it.

Adrian写道：

Adrian wrote:

>

下面是我遇到的问题的一个例子。我不明白是怎么回事
我可以让编译器看到deri& operator =（const T& rhs）。

>
Below is an example of the problem I am having. I don''t understand how
I can get the compiler to see deriv &operator=(const T &rhs).

问题是这个函数在base中不存在，这是静态的
类型。编译器只搜索对象的静态类型。

The problem is that this function doesn''t exist in base, which is the static
type. The compiler will only search the object''s static type.

>

我确定这是一个常见问题 - 任何建议？

>
I am sure this is a common problem - any suggestions?

当然。您可以投射到您真正拥有的任何类型：


dynamic_cast< deriv< int>&>（data [0]）= 12445;


另一个解决方案如下：

Surely. You can cast to whatever type you really have:

dynamic_cast<deriv<int>&>(data[0]) = 12445;

Another "solution" follows.

#include< iostream>

#include< vector>


struct base

{

#include <iostream>
#include <vector>

struct base
{

template< class Tbase& operator =（const T&）;

template <class Tbase& operator=(const T&);

virtual~base（）= 0 {};

virtual ~base()=0 {};

当然这不起作用，但你的编译器会告诉你。

of course this don''t work, but your compiler will tell you that.

} ;


模板< class T>

struct deriv：public base

{

deriv（ ）：data_（0）{};

deriv（const T& data）：data_（data）{};

deriv& operator =（const T& ; rhs）{data_ = rhs;返回（* this）; } $ / $
deriv& operator =（const deriv& rhs）

{data_ = rhs.data_;返回（* this）; }

T data_;

};

};

template<class T>
struct deriv : public base
{
deriv(): data_(0) {};
deriv(const T &data): data_(data) {};
deriv &operator=(const T &rhs) { data_=rhs; return (*this); }
deriv &operator=(const deriv &rhs)
{ data_=rhs.data_; return (*this); }
T data_;
};

模板< class T>

base& base :: operator =（const T& rhs）

{

return dynamic_cast< deriv< T>&>（* this）= rhs;

}

template <class T>
base& base::operator=(const T& rhs)
{
return dynamic_cast<deriv<T>&>(*this) = rhs;
}

>

struct container

{

base& operator []（int i）{return *（data_ [i]）; };

std :: vector< base * data_;

};


void fill_cont（container& data）;


int main（int argc，char * argv []）

{

容器数据;

fill_cont（data）;


std :: cout<< "数据[0] =" << typeid（data [0]）。name（）<< std :: endl;

//输出：data [0] = struct deriv< int>

data [0] = 12445;


std :: cout<< "数据[1] =" << typeid（data [1]）。name（）<< std :: endl;

//输出：data [1] = struct deriv< double>

data [1] = 4.5667;


std :: cout<< "数据[2] =" << typeid（data [2]）。name（）<< std :: endl;

//输出：data [2] = struct deriv< char *>

data [2] =" test" ;;

>
struct container
{
base &operator[](int i) { return *(data_[i]); };
std::vector<base *data_;
};

void fill_cont(container &data);

int main(int argc, char *argv[])
{
container data;
fill_cont(data);

std::cout << "data[0]=" << typeid(data[0]).name() << std::endl;
// output: data[0]=struct deriv<int>
data[0]=12445;

std::cout << "data[1]=" << typeid(data[1]).name() << std::endl;
// output: data[1]=struct deriv<double>
data[1]=4.5667;

std::cout << "data[2]=" << typeid(data[2]).name() << std::endl;
// output: data[2]=struct deriv<char *>
data[2]="test";

当然是测试有类型const char [5]，而不是char *，所以这不起作用。

Of course "test" has type const char[5], not char*, so this will not work.

>

返回0;

}


void fill_cont（容器和数据）

{

data.data_.push_back（new deriv< int>（））;

data.data_.push_back（new deriv< double>（））;

data.data_.push_back（new deriv< char * >（））;

}

>
return 0;
}

void fill_cont(container &data)
{
data.data_.push_back(new deriv<int>());
data.data_.push_back(new deriv<double>());
data.data_.push_back(new deriv<char *>());
}

-

Robert Bauck Hamar

来为suksess订购者：

1. Fortell aldri alt du vet。

a ?? Roger H. Lincoln

--
Robert Bauck Hamar
Der er to regler for suksess:
1. Fortell aldri alt du vet.
a?? Roger H. Lincoln

这篇关于分配操作员和基本类型的容器的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！