CODEWITHSUNDEEP
c++ooptemplatesobjectparameter-passing
Palaima
Palaima

Reputation: 331

Different objects as arguments to same function

Is it possible to pass different objects as argument for 1 function, not making 3 functions

i.e

void someFunction(Object o) {
     //working with object, all that objects have same fields to work with
     // i.e. all objects have x, y fields and this function is working with it
}

Player pl;
Item itm;
Block bl;

someFunction(pl);
someFunction(itm);
someFunction(bl);

Maybe it can be done using templates or what? I dont want to make 3 functions with same code for different objects

Upvotes: 1

Views: 2145

Answers (5)

PaperBirdMaster
PaperBirdMaster

Reputation: 13320

A template should work, but without taking SFINAE into account, you cannot assure that all the given objects have some fields.

Another solution could be inheritance here some sample code:

struct Foo
{
    int x;
    int y;
};

struct Bar: public Foo
{
    int another_x;
};

struct Baz: public Foo
{
    int another_y;
};

void someFunction(const Foo &foo)
{
    std::cout << foo.x << '\n';
    std::cout << foo.y << '\n';
};

With this approach, you can assure that all the given objects have the required members.

Upvotes: 1

ssube
ssube

Reputation: 48277

You can do this with templates or polymorphism (probably a parent interface with virtual methods to get and set relevant fields).

Templates will work and probably be well optimized, but will not allow new objects to be passed in later, regardless of whether they have the same fields. You will be able to compile new code and new objects to use the template functions, but existing calls will be stuck with a single type.

Using a parent interface and virtual methods, then making your function call those methods (presumably getters and setters) to handle the field manipulation will provide more freedom later, at the expense of slightly higher runtime and having to inherit from that interface (it will, however, allow new objects to be passed to the function at any time, so long as they implement the interface).

Upvotes: 0

David G
David G

Reputation: 96810

Templates can be used as an alias for a class of types. The following will allow any type to pass through the parameters of f.

template <typename T> void f(T & t) {
    // ...
}

Upvotes: 1

John Dibling
John Dibling

Reputation: 101456

Yes, using templates:

template<class Type> void someFunction(const Type& o) {
     //working with object, all that objects have same fields to work with
     // i.e. all objects have x, y fields and this function is working with it
}

Note that you probably will prefer to pass o by const reference, not by value. I have done this here.

Upvotes: 3

Kerrek SB
Kerrek SB

Reputation: 477150

Yes, a template should work:

template <typename T>
void someFunction(T & o)
{
    // use o.x, o.y, o.z
}

You can pass by reference or const-reference, depending on whether you want to modify the original object or not.

Upvotes: 1

Related Questions