CODEWITHSUNDEEP
c++arrayspointers
SomeUser
SomeUser

Reputation: 2041

Are array of pointers to different types possible in c++?

Are array of pointers to different types possible in c++? with example please)

Upvotes: 7

Views: 16784

Answers (8)

g_1_k
g_1_k

Reputation: 489

Since nowadays it's advised to use smart pointers I decided to rewrite the first answer using them. Here is the code you would change. Pros of using smart pointers is that it is more memory safe than raw pointers.

std::vector<std::shared_ptr<Base>> pointers;
pointers.push_back(std::make_shared<A>());
pointers.push_back(std::make_shared<B>());

Upvotes: 0

JuanJo
JuanJo

Reputation: 1

#include <stdio.h>

int main(void)
{
  void * ptr[2];
  int *a;
  int b;

  ptr[0] = "[0] = \"This is a string & c does it better\", [1] = ";
  *a = 2;
  ptr[1] = a;
  b = *((int *) ptr[1]);
  printf("%s",  (char *) ptr[0] );
  printf("%i\n", b );

  return 0;
}

Upvotes: 0

David R Tribble
David R Tribble

Reputation: 12204

Yes. Two ways:

• Pointers to a base class type, which point to objects of types derived from that base type.
• Untyped void * pointers, which must be cast manually to the actual object types they point to.

The first approach is standard object-oriented programming.

The second approach is useful for low-level programming (e.g., device drivers, memory management libraries, etc.), and is considered dangerous and suitable only for programmers who know exactly what they're doing. Obviously, it requires additional bookkeeping info to tell you what each pointer's real type is.

Upvotes: 3

stu
stu

Reputation: 8805

C++ is C with more stuff. So if you want to do it the C way, as above you just make an array of void pointers

void *ary[10];
ary[0] = new int();
ary[1] = new float();

DA.

If you want to do things the object oriented way, then you want to use a collection, and have all the things you going to be adding to the collection derive from the same base object class that can be added to the collection. In java this is "Object", C++ has no base object built in, but any collection library you use will have such a thing that you can subclass.

Upvotes: 8

Jerry Coffin
Jerry Coffin

Reputation: 490018

An array of pointers to void has already been mentioned. If you want to make it practical and useful, consider using an array (or, better, vector) of boost::any.

Upvotes: 9

Paul Sonier
Paul Sonier

Reputation: 39480

Yes; just cast your pointers in the array to whatever type you want them to refer to.

Alternately, you could make your array an array of a union (with the union elements being the differing pointer types).

Upvotes: 1

RC.
RC.

Reputation: 28197

Usually if you want to have a collection of different "types" of pointers, you implement it in a way where they derive off a base class/interface and store a pointer to that base. Then through polymorphism you can have them behave as different types.

class Base
{
public:
    virtual void doSomething() = 0;
};

class A : public Base
{
    void doSomething() { cout << "A\n"; } 
};

class B : public Base
{
    void doSomething() { cout << "B\n"; } 
};

std::vector<Base*> pointers;
pointers.push_back(new A);
pointers.push_back(new B);

Upvotes: 16

jldupont
jldupont

Reputation: 96716

... if you use a void *, it's easy ;-)

Upvotes: 3

Related Questions