cオブジェクト向けの実装からc++のオブジェクトを理解する(二)

1.クラスはstructと見なすことができ、クラスの方法は、関数ポインタによって実現されると理解することができ、クラスオブジェクトがメモリを割り当てる場合、メンバー変数のみを割り当てる場合、関数ポインタは追加のメモリ保存アドレスを割り当てる必要はありません.
2.c++のクラスのコンストラクション関数は、メモリ割り当て(malloc)を行い、コンストラクション関数を呼び出す
3.c++のクラスの構造関数、タイムリーにメモリを回収(free)
4.c++はスタックとグローバルデータに基づいてメモリを割り当て、メソッド内で作成されたオブジェクトであれば、スタックに直接メモリを割り当てます.
クローン作成に特化したコンストラクション関数は、コピー関数を構築し、プロトタイプ時に「クラス名(constクラス名&)」とし、オブジェクト全体のコピーを回避し、オブジェクトを転送する際に転送ポインタに変更し、コンストラクションコピー関数をプライベートに設定することで強制的に制限します.
5.メンバー変数はプライベートであり、コンパイル時のみ保護程度であり、実際のメモリモデルは変化しない.
6.継承は、既存の親のメモリモデルに独自のデータを追加する

#include <stdio.h>
#include <stdlib.h>

class TestClass {
public:
	int a;
	TestClass() {
		a = 1;
		printf("do constructor
");
	}

	~TestClass() {
		printf("do destructor
");
	}

	TestClass(TestClass &src) {
		a = src.a;
	}
};

void test(TestClass al) {
	printf("%d
", al.a);
}

void test(TestClass *al) {
	printf("%d
", al->a);
}

int main(void) {
	TestClass ac;
	printf("after constructor call
");
	printf("=================================
");
	test(ac);
	printf("after function call
");
}

 
7.c++マルチステートの実装:虚関数(virtual)+オブジェクトのポインタ呼び出しを使用:クラスのvirtual関数にグローバル配列が割り当てられ、アドレスが保存されます.このクラスのすべてのオブジェクトが共有されます.
自己シミュレーションでoverrideを実装する場合、実際に呼び出す実装は関数ポインタを使用し、サブクラスはこれらの関数を決定します.

/*
 * test.cpp
 *
 *  Created on: 2015 5 24 
 *      Author: jme
 */
#include <stdio.h>
#include <stdlib.h>

// 1.         
typedef void (*testFunc)();

class Base {
public:
	testFunc getHandler() {
		return func;
	}
	//     
	testFunc func;
};

void funcImpl_1() {
	printf("funcImpl_1
");
}

void funcImpl_2() {
	printf("funcImpl_2
");
}


class Sub1: public Base {
public:
	Sub1(){
		// 2.          
		func = funcImpl_1;
	}
};

class Sub2: public Base {
public:
	Sub2() {
		this->func = funcImpl_2;
	}
};

int main(void) {
	Base *baseC;
	Sub1 *upper = new Sub1();
	Sub2 *lower = new Sub2();
	baseC = upper;
	baseC->func();
	baseC = lower;
	baseC->func();
}

c++のvirtual構文:

/*
 * test.cpp
 *
 *  Created on: 2015 5 24 
 *      Author: jme
 */
#include <stdio.h>
#include <stdlib.h>


class Base {
public:
	//    
	virtual void testFunc();
	void testFunc2();
};

class Sub1: public Base {
public:
	Sub1(){
	}

	virtual void testFunc();
	void testFunc2();
};

class Sub2: public Base {
public:
	Sub2() {
	}

	virtual void testFunc();
	void testFunc2();
};

class Sub3: public Base {
public:
	Sub3() {
	}

	void testFunc();
	void testFunc2();
};

void Base::testFunc() {
	printf("base testFunc
");
}

void Base::testFunc2() {
	printf("base testFunc2
");
}


void Sub1::testFunc() {
	printf("Sub1 testFunc
");
}

void Sub1::testFunc2() {
	printf("Sub1 testFunc2
");
}

void Sub2::testFunc() {
	printf("Sub2 testFunc
");
}

void Sub2::testFunc2() {
	printf("Sub2 testFunc2
");
}


void Sub3::testFunc() {
	printf("Sub3 testFunc
");
}

void Sub3::testFunc2() {
	printf("Sub3 testFunc2
");
}

void callWithPointer(Base *baseC) {
	//         ,        ，    ，         
	baseC->testFunc();
}

void callWithoutPointer(Base baseC) {
	//         ,           ，     。
	baseC.testFunc();
}

void call2(Base *baseC) {
	//        ，                     
	baseC->testFunc2();
}

int main(void) {
	Sub1 s1;
	Sub2 s2;
	Sub3 s3;
	callWithPointer(&s1);
	callWithPointer(&s2);
	callWithPointer(&s3);
	printf("=================
");
	callWithoutPointer(s1);
	callWithoutPointer(s2);
	callWithoutPointer(s3);
	printf("=================
");
	call2(&s1);
	call2(&s2);
	call2(&s3);
}