C++面向对象

1.类对象默认初始化

#include<iostream>
#include<string>
using namespace std;
class A{
public:
	A(){};  //构造函数保证每个对象都被初始化；构造函数自动被调用
	~A(){};
	void output()
	{
		cout<<"i="<<i<<endl;  //i=-858993460
		cout<<"s="<<s<<endl;  //s=
	}
private:
	int i;     //4 Bytes
	string s;  //28 Bytes
};
int main()
{
	A a;       //调用默认构造函数；首先，调用类数据成员的默认构造函数，这里指string类；再调用A类的构造                   //函数；内置类型未初始化
	int b;     //分配内存，未初始化
	string s;  //类对象，分配内存，初始化NULL 
	a.output();
	cout<<"size of A:"<<sizeof(A)<<endl;   //32
	cout<<"size of b:"<<sizeof(b)<<endl;   //4
	cout<<"size of s:"<<sizeof(s)<<endl;   //28
	getchar();
	return 0;
}

2.构造函数初始化列表——如果子对象没有默认构造函数或如果想改变构造函数的某个默认参数

#include<iostream>
#include<string>
using namespace std;
class A{
public: 
    /*
    **构造函数初始化列表允许首先显式调用子对象的构造函数进行初始化工作，再调用自身构造函数
    **为了使语法一致，对于没有构造函数的内部类型，也可以采用这种方式初始化
    **初始化列表的主要思想：在进入新类的构造函数体之前调用所有其他子对象的构造函数
    */
	A(int aa):s("AB"),i(aa){}; 
	A(string ss,int tt):s(ss),i(tt){};
	~A(){};
	void output()
	{
		cout<<"i="<<i<<endl;
		cout<<"s="<<s<<endl;
	}
private:
	int i;     //4 Bytes
	string s;  //28 Bytes
};
int main()
{
	A a(1);     
	A b("abc",2);
	a.output();   //i=1,s=AB
	b.output();   //i=2,s=abc
	getchar();
	return 0;
}

3.继承中成员函数和成员变量隐藏问题

#include<iostream>
#include<string>
using namespace std;
class A{
public:
	A():i(1){};
	void out(){cout<<"A_i="<<i<<endl;}
private:
	int i;
};
class B:public A{
public:
	B():i(2){};
	void out(){cout<<"B_i="<<i<<endl;}
private:
	int i;
};
int main()
{
	/*构造函数的调用顺序：
	 **调用基类构造函数，调用顺序按照它们被继承时声明的顺序（从左到右）
         **调用内嵌成员对象的构造函数，调用顺序按照它们在类中声明的顺序
         **派生类的构造函数体中的内容
	*/
	B b;        //同名变量都在内存中都会存在；派生类隐藏基类同名变量
	b.out();       
	//派生类隐藏基类同名成员函数  调用派生类out函数（基类同名函数被隐藏），输出B_i=2（基类同名变量被隐藏）
	 
	getchar();
	return 0;
}
ps:
派生类和基类的函数名相同，基类同名函数就会被隐藏

‍3.this指针‍

#include<iostream>
using namespace std;
class Test{
public:
	static void test_1(){ cout<<j<<endl;}
	void test_2(){cout<<"hello,nana"<<endl;}
	void test_3(){cout<<i<<endl;}
private:
	static int j;
	int i;
};
int Test::j=2;
int main()
{
	Test *t=NULL;
    Test::test_1();  //独立
	t->test_1();    //2            静态函数，不传this指针
	t->test_2();    //hello,nana   非静态函数，传this指针，但未调用非静态数据成员
//	t->test_3();    //error        非静态函数，传this指针，调用非静态数据成员，发现对象NULL，报错
	getchar();
	return 0;
}

#类成员函数

~此类的所有对象共用每个成员函数体，当程序被编译完后，成员函数的地址已确定；

~调用类的非静态成员函数时，编译器自动将“特定”对象的地址作为参数隐含传给函数；

~一般函数参数是直接压栈，this指针被放到ecx寄存器中 

#静态成员函数

~不可以调用非静态成员函数，因为静态成员函数不含有this指针

~静态成员函数可以独立访问，不依赖对象，依赖类；

转载于:https://my.oschina.net/ingu5102/blog/480937