#include <iostream>
#include <vector>
#include <string>
#include <deque>
using namespace std;
class OpenFile {
public:
OpenFile(string filename) {cout<<"Open a file\n"<<filename ; }
void destroyMe() { delete this; }
private:
~OpenFile() {cout<<"Destroy a
file in deconstructor\n" ; }
};
//--------------------------------------------------------------------
class BigArray {
vector<int > v;
int accessCounter;
int* v2;
public:
int getItem(int index) const {
//accessCounter++;
//because using const -> can not change private member of class
const_cast <BigArray*>(this)->accessCounter++;
return v[index]; }
//getItem did not change any value of v, just take a bit of index,
getItem should be const
void setv2Item(int index, int x) const { *(v2 + index) = x; }
//this func maintain bitwise const of BigArray class,
it does not change any member of class directly
};
//--------------------------------------------------------------------
//const
and Function
class Dog {
int age;
string name;
public:
Dog() { age = 3; name = "dummy"; } //constructor
//const
parameter
//void
setAge(const int& a) { age = a; }
//func
//void
setAge(int a) { age = a;} //overload
func
//const
return value
const string getName() { return name; }
//const
func
void printDogName() const { cout << name <<" const"<< endl; }
//does
not change any member valuable of class
void printDogName() {
cout <<
getName() <<" non-const"<< endl; }
//does
not change any value of member of class
};
class Dog_ {
public:
~Dog_() { cout << "Dog destroyed\n"; }
void bark(){}
};
class YellowDog : public Dog_ {
public:
~YellowDog() { cout << "YellowDog destroyed\n"; }
};
class DogFactory{
public:
static Dog_* createYellowDog() { return (new YellowDog());}
};
int main() {
OpenFile* f = new OpenFile(string("hello world\n"));
f->destroyMe();
//-----------
Dog d;
d.printDogName();
const Dog d2;
d2.printDogName();
//-----------
Dog_* pd = DogFactory::createYellowDog();
delete pd;
return 0;
}
//-------------------------------
// 7/31
//Avoid
to call Virtual Function in Constructor or Destructor
class Cat {
public:
Cat() { cout << "Cat born." << endl; say(); }
virtual void say() { cout << "I am just a baby
cat!" << endl; }
void seeCat() { say(); }
~Cat() { say(); }
};
class Lion : public Cat{
public:
Lion() { cout << "Lion born." << endl; }
virtual void say() { cout << "I am just a yellow
lion." << endl; }
};
int main() {
Lion bucky;
bucky.seeCat();
//although
we call seeCat() of Cat class,
//say() func was called to
Lion class
}
