and below is example source for this.

#include <iostream>
using namespace std;

#define _VIRTUAL_
#define _DOUBLE_
//-------------------------------------------
class A{
private:
 int data;
public: 
 A(int data= -123){
 this->data = data;
 }
 int print(){
 cout<<"A: "<<data<<endl;
 return data;
 }
 ~A(){cout<<"~A:"<<data<<endl;}
};
//-------------------------------------------
#ifdef _VIRTUAL_
class B:virtual public A{
#else
class B:public A{
#endif
private:
 int data;
public: 
 B(int data = -2):A(data*4){
 this->data = data;
 }
 int print(){
 A::print();
 cout<<"B: "<<data<<endl;
 return data;
 }
 ~B(){ cout<<"~B:"<<data<<endl;  }
};
//-------------------------------------------
#ifdef _DOUBLE_
#ifdef _VIRTUAL_
class C:virtual public A{
#else
class C:public A{
#endif
private:
 int data;
public: 
 C(int data = -3):A(data*3){
 this->data = data;
 }
 int print(){
 A::print();
 cout<<"c: "<<data<<endl;
 return data;
 }
 ~C(){ cout<<"~C:"<<data<<endl;  }
};
#endif
//-------------------------------------------
#ifdef _DOUBLE_
class D:public B, public C{
#else
class D:public B{
#endif
private:
 int data;
public: 
#ifdef _DOUBLE_
 D(int data):B(10),C(20){
#else
 D(int data):B(10){
#endif
 this->data = data;
 }
 int print(){
 B::print();
#ifdef _DOUBLE_
 C::print();
#endif
 cout<<"D: "<<data<<endl;
 return data;
 }
 ~D(){ cout<<"~D:"<<data<<endl;  }
};
//-------------------------------------------
int main(){
 //B bb(10);
 D x(10);
 x.print();
 A(B(x)).print();
 return 0;
}

<pre>
<pre>

Class Person{
int id;
...
}; 
void Person::Print(){
cout<<id<<endl;
}

Class Student:public Person{
int grade,...
}; 
void Student::Print()
{
cout<<id<<"-"<<grade<<endl;
}

Class PartTimeStudent:public Student{
int worktime,
...
};
void PartTimeStudent::Print(){
cout<<id<<"-"<<grade<<"-"<<worktime<<endl;
}

• in somewhere, if you want to store all object type

1. store by each type of array
2. pointer type cast

• Pointer type cast

1. set parent (base) class’s pointer of array
2. anytime can create child class by new
3. created child class’s address can be assigned to parent class’s pointer
4. after use, can use delete to release memory

• Example for saving Class object to an array

Person* prs[5] = {NULL};

prs[0] = new Student(1001,100,...);

prs[1] = new PartTimeStudent(1003,90,5...);

prs[2] = new PartTimeStudent(1005,80,4....);

prs[3] = new Student(1007,99,....);

prs[4] = new PartTimeStudent(1007,100,3);

for(int i=0; i< 5; i++){

prs[i]->Print();
}
-------------------------
result will
1001
1003
1005
1007
--------------------------

What we need is.

1. call each object not all parent.
2. in run time, it needs to decide
3. Dynamic Binding
4. Polymorphism

solution is Virtual

cannot assign parent’s object to a child object.

class Person{

char* name;

int age;

};

class Student: public Person{

int grade;

char* school;

};

Parent pr;

Student st;

st = pr;   <-----Error!!

pr = st; <---OK!!

• Type cast between parent object and child pointer

child pointer cannot point parent object

Parent  pt;

Student * st = &pt; <-------Error

Student ost;

Parent * pt=&ost; <----Ok

• reference has same rule with pointer

Parent opt;

Student& rst = opt; <-----Error!!

Student ost;

Parent& rpt = ost; <----Ok!!

class object{
 int a;
 char* ap;
public:
 object(int k, char*);
 ......
 //Object(Object& ab);<---copy constructor
 ~Object();
};

Object::Object(int k, char* ap)
{
 this->a = k;
 this->ap = new char[strlen(ap)];
 .....
}
Object::~Object()
{
 delete[] ap;
}

void main(){
 Object a = new Object();

 Object b = a; <----problem
 ....doing whaever....
}<<<when exit this main block>>>

Problem of shallow copy

1.just copy primitive variable only
in above program, if there is a value for char* ap, Object b=a; will just copy int a value, not pointer ap value. so, here needs deep copy for the object.

2. there is chance application abort
when try to delete the char* ap in destructor,  memory violation will be occurred because instance a,b are point same memory to ap. so, create order of object is
a->b, but destructor order is b->a. when delete b is no problem, but trying to delete a, there is no more ap. the memory is already deleted in b(b,a point same memory).

* default constructor
if there is no copy constructor, then compiler add default copy constructor. but, it doesn’t do deep copy.

* when copy the construtor is called
1.initialize a object by exist object

object a(10);

object b(a);

2. call a function with passing object argument call by value

void functionA(Object obj1)<---call by value
void functionA(Object &obj1)<---this is call by reference

3. a function returns a object call by value

Object functionA(void)<---yes
Object& functionA(void)<---not

class A{

int a;

public:

friend class B;

friend void Get();

};

void Get(); <----Global Function

class B{

public:

void SetData(A& aa, int val){ aa.a=val;}

};

can overload by different arguments

Argument count

void function(int a, int b);
void function(int a, int b, int c);

Argument type

void func(int a);
void func(double a);

• cannot overload by return type

void func(int a);
int func(int a); (X)

here are the example of single linked list and double linked list.

Single Linked List .h file

class Stack;

class Node{
 int data;
 Node* next;
 Node(int data, Node* next = (Node*)0);
 friend class Stack;
};

class Stack{
 Node* top;
public:
 Stack();
 void push(int data);
 int pop();
 bool isEmpty();
 ~Stack();
};

this is cpp file

Node::Node(int data, Node* next){
 this->data = data;
 this->next = next;
}

Stack::Stack(){
 this->top = (Node*)0;
}
void Stack::push(int data){
 Node* newnode = new Node(data,this->top);
 // newnode->next = top; already done in constructor
 top = newnode;
}
int Stack::pop(){
 int dataout  = 0;
 if(!isEmpty()){
 dataout= top->data;
 Node* ToDel = top;
 top = top->next;
 delete ToDel;
 }
 return dataout;
}
bool Stack::isEmpty(){
 return !top;
}

Stack::~Stack(){
 while(!isEmpty()) pop();
}

this is double linked list

class DLL;
class DNode{
 char* _data;
 DNode* _next;
 DNode* _prev;
 DNode(const char* data, DNode* prev = (DNode*)0, DNode* Next= (DNode*)0);
 ~DNode();
 friend class DLL;
};

class DLL{
 DNode* _head;
 DNode* _tail;
 DNode* _cur;
 int _size;
public:
 DLL();
 ~DLL();
 // add to the end
 void Append(const char* data);
 // deletes the cur and if possible
 // cur will point to next otherwise cur
 // will point to prev
 bool Delete();
 // inserts a node between cur and cur->prev
 // cur becomes the newly inserted node
 void Insert(const char* data);
 bool IsEmpty();
 // copies the content of cur->data
 // into the data in arg list if possible
 // if failes returns false
 bool Visit(char *data);
 // counts the nodes form the beg to
 // index and returns the data of the node
 // having the fist as zero
 char* operator[](int index);
 // returns number of nodes
 int Size();
};

cpp file for double linked list

DNode::DNode(const char* data, DNode* prev, DNode* next){
 _data = new char[strlen(data)+1];
 strcpy(_data, data);
 _next = next;
 _prev = prev;
}
//----------------------------------------------
DNode::~DNode(){
 delete[] _data;
}
//----------------------------------------------
DLL::DLL(){
 _head = _tail = _cur = (DNode*)0;
 _size = 0;
}
//----------------------------------------------
DLL::~DLL(){
 while(Delete());
}
//----------------------------------------------
//Append : add to end of list
void DLL::Append(const char* data){
 DNode* nn = new DNode(data,_tail);
 if(!IsEmpty()){
 _tail->_next = nn;
 _tail = nn;
 }
 else{
 _head=_cur =_tail= nn;
 }
 _size ++ ;
}
//--------------------------------------------
//delete from head
bool DLL::Delete(){
 bool retn = false;
 if(!IsEmpty()){
 DNode* tm = _cur;
 if(_cur->_next != _cur && tm->_next){
 _cur = tm->_next;
 _cur->_prev = tm->_prev;
 }
 else{
 _cur = tm->_prev;
 _cur->_next = _tail = _cur;
 }
 delete tm;
 retn = true;
 }
 return retn;
}
//--------------------------------------------
//Insert : add to beginning of list
void DLL::Insert(const char* data){
 DNode* tp = new DNode(data,(DNode*)0,_cur);
 if(!IsEmpty()){
 _cur->_prev = tp;
 _cur = tp;
 }else{
 _head=_cur =_tail= tp;
 }
 _size++;
}
//--------------------------------------------
bool DLL::IsEmpty(){
 return !_head;
}
//--------------------------------------------
char* DLL::operator[](int index){
 _cur = _head;
 int count = 0;
 while(_cur != _tail && count != index){
 count++;
 _cur = _cur->_next;
 }
 return (char*)_cur->_data;
}
//--------------------------------------------
bool DLL::Visit(char *data)
{
 bool retn = false;
 if(!IsEmpty()){
 //data = new char[strlen(_cur->_data)+1];
 strcpy(data,_cur->_data);
 retn = true;
 }
 return retn;
}
//--------------------------------------------
int DLL::Size(){
 int count = 0;
 _cur = _head;

 while(_cur != _tail){
 count++;
 _cur = _cur->_next;
 }
 return count;
}
//--------------------------------------------

First, I can use macro to make argument to string.

#define strprint(n) printf(#n "=%d\n", n)

void main(....){

int a[5] = { 10, 20, 30, 40, 50   };
strprint(sizeof(a)); //

}

I can get this result

it result of #n, #n can covert the argument,here is n,to string. so, the argument is sizeof(a), it will becoem “sizeof(a), and make one string with “=%d\n”.

finally, the result will be printf(“sizeof(a)=%d\n”,n);

Next, we can define a predefine function to get size of array.

for example, if you want to print all value for array a(in above source), you should know the size of array to do loop.

#define sizeofArray(x) (sizeof(x) / sizeof(*(x + 0)) )

void main(...)
{

int a[5] = { 10, 20, 30, 40, 50   };

int i;

for(i=0; i < sizeofArray(p);i++) printf("%d-", p+i);

}

assert()

sizeof array

/////Case1/////

int a[3][5] = {

{ 10, 20, 30, 40, 50 },
{ 100, 200, 300, 400, 500},
{ 1000, 2000, 3000, 4000, 5000}
};

////Case2////

int x[5] = { 10, 20, 30, 40, 50 };
 int y[5] = { 100, 200, 300, 400, 500};
 int z[5] = { 1000, 2000, 3000, 4000, 5000};
 int a[3][5] = {x,y,z};

Next, if you want to access the value 10, how can you access?

&a[0] == &a[0][0] ? Same:Different;

is same or different? Yes you can get same address value. but &a[0] is correct value to access the value 10.

then what does mean a[3][5]?

it doesn’t mean array a has 15 int type of values although we can imagine all value are in memory in serial.

a—>| 10| 20| 30| 40| 50|100| 200| 300| 400|500|1000|2000|3000|4000|5000|….

but  a[3][5] means array ‘a’ has three arrays, a[0],a[1],a[2].

so, each array has int[5], namely, each array has size five int type array.

array ‘a’ is three element array and the first is a[0]. It means a == a[0]

int* p = a;    //1

int (*q)[5]=a;  //2

int** r = a;  //3

when you compile with above three case, which is makes no compile error or warning?

VC2010 show me below error for case 1

IntelliSense: a value of type “int (*)[5]” cannot be used to initialize an entity of type “int *”

for case 3

IntelliSense: a value of type “int (*)[5]” cannot be used to initialize an entity of type “int **”

however case 2, there is no error and no warning. it means case 2 is correct.

if you want use both case 1 and 3, then you should modify like this

int* p = (int*)a; //case 1

int** r = (int**)a; //case 3

again, &a[0] == int(*)[5] is true, and a==&a[0] true, therefore, int(*q)[5] == a is true too.

base on above inference, let’s think about that

how to access the value 200 with above three case :

//with this predefine

#define strprint(n) printf(#n "=%d\n", n)

strprint(*(p+6));
 strprint((*q)[6]); // == strprint(q[1][1]);
 strprint(*(r+6));

you will get this result.

which way is you feel easiest. this is important when you use it to function’s parameter. it will be totally different. let’s see.

if you want to make a function which print the value 200,

you will create like this.

//-----------------------------------
//declare case1
void fun_print(int *p);

//declare case2
void fun_print(int (*p)[4]);

//declare case3
void fun_print(**p);
//----------------------------------------------
//implement case1
void fun_print(*p){   printf("%d",p[6]); or printf("%d",*(p+6));}

//implement case2
void fun_print(int (*p)[4]){   printf("%d",p[1][1]);}

//implement case3
void fun_c3(int **p){printf("%d\n",*(p+6));}

//----------------------------------------
//when you call

fun_c1((int*)a);   //case 1 needs type cast
fun_c2(a);         //case2  without type cast
fun_c3((int**)a); //case 3 needs type cast

furthermore, it needs keep in mind that

a[0]—>&a[0][0] : a[0] points address of first value of first array

a[1]—>&a[1][0] : a[1] points address of first value of second array

a[2]—>&[2][0] : a[2] points address of first value of third array

not the each first value

--------------------------------------------------------------------------------
^ caret             the first line or beginning of string
--------------------------------------------------------------------------------
^aaa                in the beginning of string, if there is "aaa" then true,otherwise false

--------------------------------------------------------------------------------
$ dollar            end of line or end of string
--------------------------------------------------------------------------------
aaa$                in the end of line, if the line end with "aaa", then true, otherwise false

--------------------------------------------------------------------------------
. period            exact one character
--------------------------------------------------------------------------------
^a.c                "abc","adc","aZc",.. are true, "aa" is false
a..b$               end of string with these string,"aaab","abbb",azzb",..., then true

--------------------------------------------------------------------------------
[]                  bracketmeans reange or group, between two character use "-"
--------------------------------------------------------------------------------
[^xxxx]             ^ inside of [], means not
[:string class:]    string class, alpha, blank,cntrl, digit,graph,lower,print,space,upper,xdigit
[:digit:]           same with [0-9]
[:alpha:]           same with [A-Za-z]
[abc]               same with [a-c]. so, "a","b","c" one of these are true
[Yy]                Y or y is true
[A-Za-z0-9]         all alphabet and numbers
[-A-Z]              with hyphen and all capital
[^a-z]              except lowercase, all string
[^0-9]              except number, all string
[[:digit:]]         same with [0-9]

--------------------------------------------------------------------------------
{} brace            {} means range or repeat for right before the character
--------------------------------------------------------------------------------
a{3}              repeat 'a' only, so only "aaa" is true
a{3,}             'a' repeat more than three, so "aaa","aaaa","aaaaa",... are true
a{3,5}            only "aaa","aaaa","aaaaa" are true
ab{2,3}           only "abb","abbb" are true
[0-9]{2}          two digit number
doc[7-9]{2}       "doc77","doc87","doc97" ...., are true
[^Zz]{5}          without Z and z, five character, "abcde", "ttttt"..., are true
.{3,4}er          before "er" needs three or four character, Peter,mother, but not brother

--------------------------------------------------------------------------------
* asterisk        means right before character does appear 0 or more, same as {0,}
--------------------------------------------------------------------------------
ab*c              "ac", "ackdddd", "abc", "abbc", "abbbbbbbc" , etc are true
*                 there is no previous character, some characters or space are true
.*                "." means one more character, so one more characters or space are not true
ab*               "b" can repeat 0 or mroe, so 'a', "accc", "abb", "abbbbbbb" are true
a*                'a' repeat 0 or more, so k, kdd, sdfrrt, a, aaaa, abb, space, ...
doc[7-9]*         doc7,doc777,doc778989,doc,... are true
[A-Z].*           the string are composed with only capital
like.*            previous character is 'a', so like, likely, liker, likelihood...are true

--------------------------------------------------------------------------------
+  plus           previous a character repeats one or more like {1,}
--------------------------------------------------------------------------------
ab+c              abc, abckdddd, abbc, abbbbbbbc ....are true, but not ac
ab+               repeat 'b' one or more, so " ab", "abccc", "abb", "abbbbbbb"...,
like.+            after "like" one character and one or more, "likely", liker, likelihood..., but not "like"
[A-Z]+            capital string

--------------------------------------------------------------------------------
? question        previous a character repeat 0 or one
--------------------------------------------------------------------------------
ab?c              only "abc", "abcd" are true

--------------------------------------------------------------------------------
() parenthesis       it used for group in regular expression
--------------------------------------------------------------------------------
| bar             means or
--------------------------------------------------------------------------------
a|b|c             same as [a-c] means one of 'a','b','c'
yes|Yes           same as [yY]es
korea|japan       "korea" or "japan"

--------------------------------------------------------------------------------
\ backslash       use to display special character in the string
--------------------------------------------------------------------------------

This is the example of Csharp

class Validation
{
 public static void Main()
 {
 String strToTest;
 Validation objValidate = new Validation();
 Console.Write("Enter a String to Test for Alphabets:");
 strToTest = Console.ReadLine();
 if (objValidate.IsAlpha(strToTest))
 {
 Console.WriteLine("{0} is Valid Alpha String", strToTest);
 }
 else
 {
 Console.WriteLine("{0} is not a Valid Alpha String", strToTest);
 }
 }
 // Function to test for Positive Integers.
 public bool IsNaturalNumber(String strNumber)
 {
 Regex objNotNaturalPattern = new Regex("[^0-9]");
 Regex objNaturalPattern = new Regex("0*[1-9][0-9]*");
 return !objNotNaturalPattern.IsMatch(strNumber) &&
 objNaturalPattern.IsMatch(strNumber);
 }
 // Function to test for Positive Integers with zero inclusive
 public bool IsWholeNumber(String strNumber)
 {
 Regex objNotWholePattern = new Regex("[^0-9]");
 return !objNotWholePattern.IsMatch(strNumber);
 }
 // Function to Test for Integers both Positive & Negative
 public bool IsInteger(String strNumber)
 {
 Regex objNotIntPattern = new Regex("[^0-9-]");
 Regex objIntPattern = new Regex("^-[0-9]+$|^[0-9]+$");
 return !objNotIntPattern.IsMatch(strNumber) && objIntPattern.IsMatch(strNumber);
 }
 // Function to Test for Positive Number both Integer & Real
 public bool IsPositiveNumber(String strNumber)
 {
 Regex objNotPositivePattern = new Regex("[^0-9.]");
 Regex objPositivePattern = new Regex("^[.][0-9]+$|[0-9]*[.]*[0-9]+$");
 Regex objTwoDotPattern = new Regex("[0-9]*[.][0-9]*[.][0-9]*");
 return !objNotPositivePattern.IsMatch(strNumber) &&
 objPositivePattern.IsMatch(strNumber) &&
 !objTwoDotPattern.IsMatch(strNumber);
 }
 // Function to test whether the string is valid number or not
 public bool IsNumber(String strNumber)
 {
 Regex objNotNumberPattern = new Regex("[^0-9.-]");
 Regex objTwoDotPattern = new Regex("[0-9]*[.][0-9]*[.][0-9]*");
 Regex objTwoMinusPattern = new Regex("[0-9]*[-][0-9]*[-][0-9]*");
 String strValidRealPattern = "^([-]|[.]|[-.]|[0-9])[0-9]*[.]*[0-9]+$";
 String strValidIntegerPattern = "^([-]|[0-9])[0-9]*$";
 Regex objNumberPattern = new Regex("(" + strValidRealPattern + ")|(" + strValidIntegerPattern + ")");
 return !objNotNumberPattern.IsMatch(strNumber) &&
 !objTwoDotPattern.IsMatch(strNumber) &&
 !objTwoMinusPattern.IsMatch(strNumber) &&
 objNumberPattern.IsMatch(strNumber);
 }
 // Function To test for Alphabets.
 public bool IsAlpha(String strToCheck)
 {
 Regex objAlphaPattern = new Regex("[^a-zA-Z]");
 return !objAlphaPattern.IsMatch(strToCheck);
 }
 // Function to Check for AlphaNumeric.
 public bool IsAlphaNumeric(String strToCheck)
 {
 Regex objAlphaNumericPattern = new Regex("[^a-zA-Z0-9]");
 return !objAlphaNumericPattern.IsMatch(strToCheck);
 }
}