25

See the code below.

a) Does, in this case (simple inheritance, no virtual members), the static cast in B::df() have any overhead (whatsoever)? I found some conflicting answers to similar questions, that's why I am asking...

b) I was thinking about making const M1 * func private in A and introducing a new private field const M2 * func into B to avoid the cast, but it kind of complicates things up and makes use of smart pointers more difficult. Do you see a better way to avoid the cast?


class M1 {
public:
    double f() const;
};


class M2 : public M1 {
public:
    double df() const;
};



class A {
protected:
    const M1 * func;
public:
    A(const M1 * p);
    ~A();
    double f() const;
};



class B : public A {
public:
    B(const M2 * p);
    double df() const;
};



double M1::f() const { return 1973.0; }
double M2::df() const { return 0.0; }


A::~A() { delete func; }
A::A(const M1 * p) : func(p) {}
double A::f() const { return func->f(); }



B::B(const M2 * p) : A(p) {}
double B::df() const { return static_cast<const M2*>(func)->df(); }
Petr
  • 1,128
  • 2
  • 14
  • 23

1 Answers1

55

static_cast<T>(e) is equivalent to creating an invented temporary variable v in the following way:

T v(e); //where T is an arbitrary type  and e is an arbitrary expression.

The runtime cost of a static_cast is exactly the cost of the above statement

Armen Tsirunyan
  • 130,161
  • 59
  • 324
  • 434
  • So it does have some overhead in creating that temporary object every time B::df() is called. From this point of view it could be advantageous to store one more member variable in B to avoid the temporary. Right? – Petr Jun 22 '11 at 20:16
  • 19
    @Petr: You are casting pointers. A copy of a pointer (which may be optimized away by the compiler anyway) is a negligable operation. I wouldn't try to optimize it – Armen Tsirunyan Jun 22 '11 at 20:18