I have class _A and other classes derived from _A. I need to make a function that can work with an array of pointers to _A. And this function should work with an array of pointers to derived classes as well.

I write:

class _A{...};
class _B: public _A{...};

void ShowArray(_A **Array, int size)
{
	for(int n(0); n<size; ++n) cout << Array[n]->memberA << " ";
}

Then I can call this function like this:

_A **ArrayA;
_B **ArrayB;

...

ShowArray(ArrayA,10);
ShowArray((_A**)ArrayB,10);

Everything is OK.

But what can I do if I need to work with an array "vector" from STL ?
How can I write such a function that can work with vector<_A *> and every other array of pointers of derived of _A type?

Here is full code to understand a problem:

#include <iostream>
#include <vector>

using namespace std;

class _A
{ public:
	int memberA;
	_A(int memberA):memberA(memberA){;}
};

class _B: public _A
{ public:
	int memberB;
	_B(int memberA,int memberB):_A(memberA),memberB(memberB){;}
};

void ShowArrayAOldStyle(_A **Array, int size)
{
	for(int n(0); n<size; ++n)
		cout<<Array[n]->memberA<<" ";
	cout<<endl;
}

void ShowArrayANewStyle(vector<_A *> &Array)
{
	for(vector<_A *>::size_type n(0); n<Array.size(); ++n)
		cout<<Array[n]->memberA<<" ";
	cout<<endl;
}

void ShowElemA(_A *Elem)
{
	cout<<Elem->memberA<<endl;
}

int main(int argc, char **argv)
{
	int const numObjects = 3;

	_A **ArrayAOldStyle = new _A*[numObjects];
	_B **ArrayBOldStyle = new _B*[numObjects];
	vector<_A *> ArrayANewStyle(numObjects);
	vector<_B *> ArrayBNewStyle(numObjects);

	for(int n(0); n<numObjects; ++n)
	{
		ArrayAOldStyle[n]=new _A(1);
		ArrayBOldStyle[n]=new _B(2,3);
		ArrayANewStyle[n]=new _A(4);
		ArrayBNewStyle[n]=new _B(5,6);
	}

	ShowElemA(ArrayAOldStyle[0]); //Good
	ShowElemA(ArrayBOldStyle[0]); //Good
	ShowElemA(ArrayANewStyle[0]); //Good
	ShowElemA(ArrayBNewStyle[0]); //Good

	ShowArrayAOldStyle(       ArrayAOldStyle,numObjects); //Good
	ShowArrayAOldStyle((_A**) ArrayBOldStyle,numObjects); //Good, but there is no automatic type conversion
	ShowArrayANewStyle(ArrayANewStyle); //Good
	ShowArrayANewStyle(ArrayBNewStyle); //BAD. What to do???

	for(int n(0); n<numObjects; ++n)
	{
		delete ArrayAOldStyle[n];
		delete ArrayBOldStyle[n];
		delete ArrayANewStyle[n];
		delete ArrayBNewStyle[n];
	}

	return 0;
}

I hope you can understand english.

Und ich hoffe du kannst Deutsch.

SAn schrieb:

I have class _A and other classes derived from _A.

Nein. Namen, die mit _ anfangen gehören dem Compiler, so darfst du deine Klasse nicht nennen.

template <typename T>
void ShowArrayAEvenNewerStyle(std::vector<T*> const& Array)
{
    for(std::vector<T*>::const_iterator i = Array.begin (); i != Array.end (); ++i)
        std::cout << i->memberA << ' ';
    std::cout << std::endl;
}

template<typename T> 
void ShowArrayANewStyle(T &Array)
{
    for(vector<_A *>::size_type n(0); n<Array.size(); ++n)
        cout<<Array[n]->memberA<<" ";
    cout<<endl;
}

I am using "_" to distinguish between types (classes) names and objects names.

The solution you provided is works. But there is no automatic checking of the inheritance. A user of such function can provide array of every type to the function.

Is it possible to say compiler that class T in your example MUST be derived from _A class?

SAn schrieb:

I hope you can understand english.

Und ich hoffe du kannst Deutsch.

Idiot.

I am using "_" to distinguish between types (classes) names and objects names.

http://www.cse.iitb.ac.in/~karkare/Gc/coding/

Names starting with _ (underscore) and __ (two underscores) are reserved for compiler writers. These should be avoided.

And I did not write the last message containing "idiot". This is a someone's joke.

class A
{
};

class B : public A
{
};

class C
{
};

void func(A const& val)
{ //do something
}

int main(int, char**)
{
 A a;
 B b;
 C c;

 func(a); //works
 func(b); //should work as well
 func(c); //compile time error
}

inp, yes. The problem is to do the same behaviour with arrays of pointers, not just with pointers.

yes, i got that.

but A** isnt B**.
anyway A** can store elements of type B*
so why not use a constistent scheme and use just basettype pointerarrays

class A
{
public:
	virtual void WhoAmI()
	{	printf("A\n");
	}
};

class B: public A
{
public:
	virtual void WhoAmI()
	{	printf("B\n");
	}
};

void func(A** arr, size_t num)
{
	for (size_t i = 0; i < num; ++i)
		arr[i]->WhoAmI();
}

int main(argc, char**)
{
	A** a = new A*[1];
	A** b = new A*[1];

	a[0] = new A();
	b[0] = new B();

	func(a, 1);
	func(b, 1);

	return 0;
}

inp, yes. The problem is to do the same behaviour with arrays of pointers, not just with pointers.

That is not possible (well, unless you write your own array/vector-class to simulate it - and then there's more than one way to do it too). The reason is simply that when you convert a pointer to a derived class to a pointer to an (accessible and unambigous) base class that converted pointer ceases to point to your derived class. What you can do is converting rvalue pointers, i.e. the values of pointer objects. What you cannot do is to convert lvalues of pointer type to other lvalues of pointer type which pointed to different objects. And that is really what you do when you have an array

struct Foo {};
struct Bar : Foo {};
Bar* x[N];

and try to cast it

(Foo*(&)[N])x;

Because that means that you want to treat each element of x as if it was an object containing a pointer to Foo. For one, pointers to different types may not have the same object representation. But more importantly, they may not even have the same value when converting one to another (using a suitable point of reference: void*). One pointer points to the Bar object and the other to the Foo subobject within the Bar object and those two need not share the same address. As a general rule - laid down in ancient C times - two different (living - so we ignore unions here) objects do not have the same address. There are only two exceptions to that: the first member of class may have the same address as the class itself (and in case of PODs that is required) and a base class subobject may (but need not) have the same address as the object of the derived class.

This comes down to a simple rule: never treat arrays polymorphically. Polymorphism applies to individual pointers and references only, never to collections of them.

But the previous messages bring me to the following idea:

inline void CheckType(A *a){;}

template <typename T> void ShowArrayA(vector<T*> &Array)
{
  if(!Array.size()) return;

  CheckType(Array[0]); //Check if T derived from A. I think the clever compiler will generate empty code for this

  for(vector<T*>::size_type n(0); n<Array.size(); ++n)
    cout << Array[n]->memberA << ' ';

  cout << endl;
}

This looks ugly, but I think it should work.

camper, thank you for the detailed explanation.

But more importantly, they may not even have the same value when converting one to another

This is new to me. I thought that each pointer points to the very first byte of the object. And base class subobject always have the same address as the object of the derived class.

But now I understand that it is compiler-specific.

I can not use virtual functions due to performance issues.

there are plenty ways how to counter performance problems.

But more importantly, they may not even have the same value when converting one to another

This is new to me. I thought that each pointer points to the very first byte of the object. And base class subobject always have the same address as the object of the derived class.

But now I understand that it is compiler-specific.

Think multiple inheritance.

template <typename InputIterator>
void ShowArrayA( InputIterator first, InputIterator last )
{
  for ( ; first != last; ++first)
    std::cout << (*first)->memberA << ' ';
  std::cout << endl;
}

#include <algorithm>
#include <iterator>
#include <boost/iterator/indirect_iterator.hpp>

std::ostream& operator<<( std::ostream& out, _A const& obj )
{
  return out << obj.memberA;
}

template <typename InputIterator>
void ShowArrayA( InputIterator first, InputIterator last )
{
  std::copy(
    boost::make_indirect_iterator(first),
    boost::make_indirect_iterator(last),
    std::ostream_iterator<_A>(std::cout, " "));
  std::cout << std::endl;
}

// test

ShowArrayA(ArrayAOldStyle, ArrayAOldStyle + numObjects);
ShowArrayA(ArrayANewStyle.begin(), ArrayANewStyle.end());
ShowArrayA(ArrayBOldStyle, ArrayBOldStyle + numObjects);
ShowArrayA(ArrayBNewStyle.begin(), ArrayBNewStyle.end());