How can 2 different classes point to the same datatable name

I need to initialize an object in a method without specifying the class from where the object is. Can I do that?

can开发者_开发问答 someone give me an example?

EDIT:

MyClass{
...};
MySecondClass
{...
};
void method(*object); //how to write correct??
{..}
MyClass *x= new MyClass();
MySecondClass *y= new MySecondClass();
method(x);
method(y);

Use templates.

template <typename T>
void method(T* object) {
   // do stuff with the object, whose real type will be substituted for `T`
}

Templates are a bit complex, so read the chapter in your C++ book on them for more information.

It sounds like you're looking for an interface. You would define an interface that fits the needs of whatever it is that your method is doing.

class MyInterface 
{
    public:
    virtual void doSomething1() = 0;
    virtual void doSomething2() = 0;
};


class MyObject : public MyInterface
{
    public:
    void doSomething1()
    {
        // Code here
    }

    void doSomething2()
    {
        // Code here
    }
};

It's somewhat unclear exactly the situation you have b/c you haven't shown any code, but make the method you want to call part of a class. (if it isn't already)

class ClassWithMethod
{
    public:
    ClassWithMethod(MyInterface &myI)
        :x(myI)
    {
    }

    void methodYouUseInjectedObject()
    {
        // Code
        x.doSomething1();
        // More code
    }

    private:
    MyInterface &x;

};

Then in you application code where you instantiate the ClassWithMethod, you would "inject" the concrete type of the object you want called.

int main(int argc, char *argv[])
{
    MyObject myObject;

    ClassWithMethod classMethod(myObject);

    // Call the method that will use the injected object.
    classMethod.methodYouUseInjectedObject();
    return 1;
}

EDIT: (based on updated question)

If you want to create a method that can take two different (and unrelated) objects, but the use the same method signatures you can use a template.

 class ClassWithMethod
    {
        public:
        template <class T>
        void methodYouUseInjectedObject(T object)
        {
            T.doSomething();
        }

    };

This is similar to my approach above except that you do not need to derive your different objects off an interface.

You can use a template.

template<typename T>
void method(T object) {
    object.doSomething()
}