Incorrect object oriented programming

#include <iostream>
class myClass {
public: 
  void method() {}
};

void main() {
  myClass Obj;
  int (myClass::*methodPtr) (void) = (int (myClass::*) (void)) &myClass::method;
  int res = (Obj.*methodPtr)();
  std::cout << "Result = " << res;
}

In this example, the pointer methodPtr has return type int but points to myClass:method that has return type void. Therefore, when methodPtr is dereferenced, the Incorrect object oriented programming check produces a red error.

#include <iostream>
class myClass {
public:
  void method() {}
};

void main() {
  myClass Obj;
  void (myClass::*methodPtr) (void) =  &myClass::method;
  methodPtr = 0;
  (Obj.*methodPtr)();
}

In this example, methodPtr has value NULL when it is dereferenced.

class Shape {
public:
  Shape(Shape *myShape) {
    myShape->setShapeDimensions(0.0);
  }
  virtual void setShapeDimensions(double) = 0;
};

class Square: public Shape {
  double side;
public:
  Square():Shape(this) {
  }
  void setShapeDimensions(double);
};

void Square::setShapeDimensions(double val) {
  side=val;
}

void main() {
  Square sq;
  sq.setShapeDimensions(1.0);
}

In this example, the derived class constructor Square::Square calls the base class constructor Shape::Shape() with its this pointer. The base class constructor then calls the pure virtual function Shape::setShapeDimensions through the this pointer. Since the call to a pure virtual function from a constructor is undefined, the Incorrect object oriented programming check produces a red error.

#include <new>

class Foo {
public:
  void funcFoo() {}
};


class Bar {
public:
  virtual void funcBar() {}
};

void main() {
  Foo *FooPtr = new Foo;
  Bar *BarPtr = (Bar*)(void*)FooPtr;
  BarPtr->funcBar();
}

In this example, the classes Foo and Bar are not related. When a Foo* pointer is cast to a Bar* pointer and the Bar* pointer is used to call a virtual member function of class Bar, the Incorrect object oriented programming check produces a red error.

#include <new>
class Foo {
public:
    virtual void func() {}
};

void main() {
    Foo *FooPtr = new Foo[4];
    for(int i=0; i<=4; i++)
        FooPtr++;
    FooPtr->func();
    delete [] FooPtr;
}

In this example, the pointer FooPtr points outside the allocated bounds when it is used to call the virtual member function func(). It does not point to a valid object. Therefore, the Incorrect object oriented programming check produces a red error.

class Foo {
public:
  virtual int func() {
    return 1;
  }
};

class Ref {
public:
  Ref(Foo* foo) {
    foo->func();
  }
};

class Bar {
private:
  Ref m_ref;
  Foo m_Foo;
public:
  Bar() : m_ref(&m_Foo) {}
};

In this example, the constructor Bar::Bar() calls the constructor Ref::Ref() with the address of m_Foo before m_Foo is initialized. When the virtual member function func is called through a pointer pointing to &m_Foo, the Incorrect object oriented programming check produces a red error.

To reproduce the results, analyze only the class Bar using the option Class (-class-analyzer).

#include <new>

class Foo {
public:
  virtual void funcFoo() {}
};


class Bar: public Foo {
public:
  void funcFoo() {}
};

void main() {
  Foo *FooPtr = new Foo;
  Bar *BarPtr = (Bar*)(void*)FooPtr;
  BarPtr->funcFoo();
}

In this example, you might intend to call the derived class version of funcFoo but depending on your compiler, you call the base class version or encounter a segmentation fault.

The pointer FooPtr points to a Foo object. The cast incorrectly attempts to convert the Foo* pointer FooPtr to a Bar* pointer BarPtr. BarPtr still points to the base Foo object and cannot access Bar::funcFoo.

#include <new>

class Foo {
public:
  virtual void funcFoo() {}
};


class Bar: public Foo {
public:
  void funcFoo() {}
};

void main() {
  Foo *FooPtr = new Bar;
  FooPtr->funcFoo();
}