By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
448,679 Members | 1,030 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 448,679 IT Pros & Developers. It's quick & easy.

Cast vector<foo*> to vector<const foo*>?

P: n/a
Some function requires a vector<const foo*> argument.
How can I cast a vector<foo*> to vector<const foo*>?

Thanks!

Joseph

Jan 26 '06 #1
Share this Question
Share on Google+
8 Replies


P: n/a
Joseph Turian wrote:
Some function requires a vector<const foo*> argument.
How can I cast a vector<foo*> to vector<const foo*>?

You can't; they are completely different types.

--
Ian Collins.
Jan 26 '06 #2

P: n/a

Ian Collins wrote:
How can I cast a vector<foo*> to vector<const foo*>?

You can't; they are completely different types.


Care to edify me why?
At first blush, they seem quite similar.

Joseph

Jan 26 '06 #3

P: n/a
Joseph Turian wrote:
Ian Collins wrote:
How can I cast a vector<foo*> to vector<const foo*>?


You can't; they are completely different types.

Care to edify me why?
At first blush, they seem quite similar.

An instantiation of a class template is a unique class. Don't be fooled
by the template type, it my look similar to you, but it's apples and
oranges to the compiler. foo* and const foo* are different types.

--
Ian Collins.
Jan 26 '06 #4

P: n/a
"Joseph Turian" <tu****@gmail.com> wrote in message
news:11**********************@g44g2000cwa.googlegr oups.com
Ian Collins wrote:
How can I cast a vector<foo*> to vector<const foo*>?

You can't; they are completely different types.


Care to edify me why?
At first blush, they seem quite similar.

Joseph


To add to what Ian has said,

foo * and const foo * are different types but are nevertheless similar
enough that you can use const_cast to cast between them. Where two types are
used as template arguments, however, the similarity of the types is
irrevant. Consider:

template<class T>
class Test
{
T t;
};

template<>
class Test<const int>
{
char array[1000];
};

Thus Test<const int> contains an array of chars, whereas Test<int> contains
a single int.

#include <iostream>
using namespace std;

int main()
{
Test<int> t1;
Test<const int> t2;
cout << sizeof(t1) << endl; // gives 4
cout << sizeof(t2) << endl; // gives 1000
return 0;
}

In reality vector<foo *> and vector<const foo *> may hardly differ at
all --- in particular, they may have the same size. However, the possibility
of explicit template specialization means that they could differ
spectacularly, hence the reluctance of the compiler to allow conversion.
--
John Carson
Jan 26 '06 #5

P: n/a
Joseph Turian wrote:
Some function requires a vector<const foo*> argument.
How can I cast a vector<foo*> to vector<const foo*>?


As said, you can't cast.

You'll have to copy each element.

Ben Pope
--
I'm not just a number. To many, I'm known as a string...
Jan 26 '06 #6

P: n/a

Ben Pope wrote:
Joseph Turian wrote:
Some function requires a vector<const foo*> argument.
How can I cast a vector<foo*> to vector<const foo*>?


As said, you can't cast.

You'll have to copy each element.


You have to copy each element if you want a vector< const Foo * >

However if all you want to do is pass a reference to your vector and
ensure that none of the Foo objects are modified, you can use an
adapter,

template < typename T >
vector_const_adapter
{
typedef std::vector< T * > vec_type;

const vec_type * itsVecRef;

public:

typedef typename vec_type::size_type size_type;

vector_const_adapter() : itsVecRef( 0 ) {}

vector_const_adapter( const vec_type & vecRef )
: itsVecRef( &vecRef )
{
}
const T* operator[] ( size_type idx ) const
{
return (*itsVecRef)[ idx ];
}

bool empty() const;
size_type size() const;
const T* const * begin() const;
const T* const * end() const;
};

and I'll leave it up to you to implement the functions empty() size(),
begin() and end()

Now all you have to do is pass around vector_const_adapter<Foo>. Note I
used a member pointer so that vector_const_adapter can have a default
constructor and be assignable. If you don't want these features use a
member reference.

Jan 26 '06 #7

P: n/a
"Joseph Turian" <tu****@gmail.com> wrote in message
news:11**********************@g44g2000cwa.googlegr oups.com...
Ian Collins wrote:
> How can I cast a vector<foo*> to vector<const foo*>? You can't; they are completely different types.

Care to edify me why?
At first blush, they seem quite similar.


Here is one reason:

void append(vector<const foo*>& v, const foo* p)
{
v.push_back(p);
}

const foo f;
const foo* p = &f;
vector<foo*> v;
append(v, p);

By casting v to vector<const foo*>&, you have managed to put a const foo*
value into a vector<foo*>. Now, you can execute

v.last()->munge();

where munge is a member of class foo that modifies its object. By doing so,
you have modified a const foo object.

Jan 26 '06 #8

P: n/a

Andrew Koenig wrote:
Care to edify me why?
At first blush, they seem quite similar.


Here is one reason:

void append(vector<const foo*>& v, const foo* p)
{
v.push_back(p);
}

const foo f;
const foo* p = &f;
vector<foo*> v;
append(v, p);

By casting v to vector<const foo*>&, you have managed to put a const foo*
value into a vector<foo*>. Now, you can execute

v.last()->munge();

where munge is a member of class foo that modifies its object. By doing so,
you have modified a const foo object.


Something you couldn't do with my adapter as you cannot modify the
vector either thus you can't push anything onto it.

Jan 27 '06 #9

This discussion thread is closed

Replies have been disabled for this discussion.