在c + +中有一种方法可以将指针转换为它所指向的实际类型？

Question

Edited. see below.

Consider the following situation - I have a base class and some derived ones :

class B {...[virtual...]...};

class D1 : public B {...};

class D2 : public B {...};

and I have a function that suppose to behave differently on each of them (implement-wise. conceptually, they all do the same thing). now, I would of course implement an auxiliary function for each :

void f_aux (B * b);
void f_aux (D1 * d1);
void f_aux (D2 * d2);

and then I can implement the main function by doing something like this :

void f (B * bd1d2) {
       if (typeid(bd1d2) == typeid(B*)  { f_aux((B*)bd1d2);  }
  else if (typeid(bd1d2) == typeid(D1*) { f_aux((D1*)bd1d2); }
  else if (typeid(bd1d2) == typeid(D2*) { f_aux((D2*)bd1d2); }
}    

now, my question is - can I do this in a general way, meaning something like :

void f (B * bd1d2) {
       f_aux(CAST_TO_REAL_TYPE(bd1d2));
}    

I tried using typeid directly which of course failed. I tried searching that online and nothing came up..

so, Is there a way of doing it? and if there isn't, than why?

many thanks..

Edit :

I tried to simplify the problem, and it seems that I've done the opposite.. Let me try again : In the real settings, I have 3 classes : Line, Ray and Segment, and I'd like another class (a Graph-Edge) to hold a general pointer to an object any of the types - meaning, it has a field that can be either Line Ray or Segment. Now, I'd like to have the option to get an intersection point of 2 Graph-Edges, or of a Graph-Edge with a given Line/Ray/Segment without dealing with the question of "what kind of an edge is this?" on none of the two. I would also like to have my Geometry classes as generic as possible, even if some of the functionality is not necessary in Graph-Edges.. So I made a super-class : LinearObject, with a virtual getCut(LinearObject & lo) function, and followed the answers below, and the best I've got so far is this :

class Line;
class Segment;

class LinearObject {
public :
    virtual void getCut(LinearObject * lo) { printf("lo->lo\n"); }
private :
    virtual void getCut_aux(Line * l) = 0;
    virtual void getCut_aux(Segment * s) = 0;

friend class Line;  friend class Segment;
};

class Line : public LinearObject {
public :
    void getCut(LinearObject * lo) { printf("l->lo\n"); lo->getCut_aux(this); }
private :
    void getCut_aux(Line * l) { printf("l->l\n"); }
    void getCut_aux(Segment * s) { printf("l->s\n"); }
};

class Segment : public LinearObject  {
public :
    void getCut(LinearObject * lo) {
        printf("s->lo\n");
        lo->getCut_aux(this);
    }
private :
    void getCut_aux(Line * l) { printf("s->l\n"); }
    void getCut_aux(Segment * s) { printf("s->s\n"); }
};

int main() {
    Line l; Segment s;
    LinearObject *lop = &l, *lop2 = &s;
    lop->getCut(lop2);
    s.getCut(&l);
    return 0;
}

It works, but, can I do any better (Eleganltly) ?

Answer 1

Edit: Edit after you question edit, hope I understand everything you want...

#include <cstdio>

class Line;
class Segment;

class LinearObject {
protected :
    virtual void getCut_aux(LinearObject *) { printf("LinearObject->getCut_aux\n") ; }

    friend class LinearObject_ ;
};

class LinearObject_ : public LinearObject {
public:
    void getCut (LinearObject * lo) { printf("getCut()\n"); lo->getCut_aux(this) ; }
};

class Line : public LinearObject_ {
protected :
    virtual void getCut_aux(LinearObject *) { printf("Line->getCut_aux\n") ; }

};

class Segment : public LinearObject_  {
protected:
    virtual void getCut_aux(LinearObject *) { printf("Segment->getCut_aux\n") ; }
};

int main() {
    Line l; Segment s;
    LinearObject *lop = &l, *lop2 = &s;
    l.getCut(lop2);
    s.getCut(&l); 
    return 0;
}

End of edit.

If you can implement f_aux inside the class, just take advantage of polymorphism:

class B {
    /* ...[virtual...]... */
    virtual void f_aux () { /* ... */ } 
};

class D1 : public B {
    /* ... */
    virtual void f_aux () { /* ... */ } 
};

class D2 : public B {
    /* ... */
    virtual void f_aux () { /* ... */ } 
};

Then just do:

void f (B * bd1d2) {
    bd1d2->f_aux () ; // Will call the correct function depending on what bd1d2 points to
}

Edit: To answer your comment, if you want to have something like d->f_aux(b) just add an intermediate class D :

class D {
    void f (B *b) { b->f_aux(this) ; }
};

class D1 : public B, public D { /* ... */ };

B  *pdb = new B (), *pd3 = new D3 () ;
D1 *pd1 = new D1 () ;
D2 *pd2 = new D2 () ;
pd1->f(b) ;
pd2->f(pd3) ;

Answer 2

The "correct" solution for this is to do something like is to use virtual functions:

void f_aux (B * b)
{
  b->do_f_aux();
}

where you declare do_f_aux as

class B 
{
 ... 
 virtual void do_f_aux() { ... }; 
}

and of course implement the do_f_aux differently in d1 and d2 .

[This assumes you need f_aux as a standalone function - if you just need a function that does this, then just call the virtual function f_aux , and call it directly in the f as bd1d2->f_aux() ]

Edit:

Casting objects in the way you describe is a "bad smell" ( http://en.wikipedia.org/wiki/Code_smell ) - a symptom of "you're doing it wrong". It can almost always be avoided by using virtual functions.