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()
}