Beyond the Sky

What is the different between pure virtual function and virtual function?

Virtual function is used to ease polymorphism implementation, which allows the c++ compiler to differentiate the actual "type" of the objects created which derived from a base class.

Pure virtual function is also virtual function, but it do not have a body. It looks just like a function declaration, and it forced the derived class to implement the function defination. (compiler gives error if the derived class do not define the pure virtual function). The base class that contains pure virtual function is call abstract class. It defines generic interfaces without specified the functionalities.

How to declare virtual function and pure virtual function?
That is simple, just add the magic keyword infront of the function you wanna turn it to virtual function:

class CPolygon {
  protected:
    int width, height;
  public:
    void set_values (int a, int b)
      { width=a; height=b; }
    virtual int area () //THIS MAKES THE FUNCTION VIRTUAL
      { return (0); }
  };

How about Pure Virtual Function?

class CPolygon {
  protected:
    int width, height;
  public:
    void set_values (int a, int b)
      { width=a; height=b; }
    virtual int area ()=0; //PURE, NO INLINE DEFINATION
  };

I remember when I first learn about pure virtual function, it was 6 years ago. Never used and exam also didn't covers. Its been awhile I didn't really touch Object-Oriented C++.

//: C13:BadVoidPointerDeletion.cpp
//// Deleting void pointers can cause memory leaks
#include <iostream>
using namespace std;
class Object {
   void* data; // Some storage
   const int size;
   const char id;
   public:
   Object(int sz, char c) : size(sz), id(c) {
   data = new char[size];
   cout << "Constructing object " << id
        << ", size = " << size << endl;
             }
   ~Object() {
   cout << "Destructing object " << id << endl;
   delete []data; // OK, just releases storage,
                  // no destructor calls are necessary
             }        };

int main() {
         Object* a = new Object(40, 'a');
         delete a;
         void* b = new Object(40, 'b');  
         delete b; //delete b without calling constructor will cause the data[] unreleased 
                   //and leads to memory leak.
           } ///:~ picked from pg 584 of thinking in c++ by bruce

When you compile this code, it do have warning:

$ g++ -o memleak{,.cc}
memleak.cc: In destructor 'Object::~Object()':
memleak.cc:17: warning: deleting 'void*' is undefined
memleak.cc: In function 'int main()':
memleak.cc:26: warning: deleting 'void*' is undefined

If you run it, you get the output:

Constructing object a, size = 40
Destructing object a
Constructing object b, size = 40

Destructor of object b is not called, it causes memory leak.

When you want to create a constant in class which every object initialized from the class has its own different const value. That means the value must be initialized when instanciate and it do not allow to change for the rest of the time. This is the first time I read about this.

//: C08:ConstInitialization.cpp
// Initializing const in classes
#include <iostream>
using namespace std;
class Fred {
const int size;
public:
Fred(int sz);
void print();
};
Fred::Fred(int sz) : size(sz) {} // THE IMPORTANT PART
void Fred::print() { cout << size << endl; }
int main() {
Fred a(1), b(2), c(3);
a.print(), b.print(), c.print();
} ///:~

I discover something awkful while I read c++ source code of ns2.
Here is something i sort out for example

#include<iostream>
using namespace std;

class setup{
        private:
                int h;
        public:
                inline setup(){h=0;}
                inline int& seth(){ return h;}//here is the wonder
                inline void print(){ cout<<h<<endl;}
};

int main()
{
        setup s;
        s.print();
        s.seth()=5;//how could it happen?
        s.print();
        return 0;
}

When I look at the line similar like "s.seth()=5", i confused, I never see these kind of code before. But it works and it make sense. The inline function seth() in the class is actually return the memory address of "h", by storing value to a variable memory address, it make sense and it works.