C++类和对象

直接看笔记http://t.csdnimg.cn/McEGs

不用啦，接下来就是写重点的理解部分啦，关注深入的理解

1.构造函数知识点

1.构造函数的目的：给类内的成员一个初始值，在int main里能够初始化它

类内：
class{
...
X（int v){m=v;}
...
}
class{
...
Y(){m=0;}
Y(char c){ch=c;}
...
}
int main()
{
X x1(5);//因为上面有构造函数里面有一个int类型的参数
Y y1;//因为上面有一个没有参数的函数
Y y2('a');//因为上面有一个有一个char类型的参数的构造函数
}

2.构造函数初始化列表

解决了之前的问题，相当于对构造函数的改进，为什么要改进，因为如果类内有定义引用的变量，那么不能再构造函数内赋值，因为引用必须在定义时候初始化，方法是啥，就是给构造函数参数列表后面写个冒号，然后采用   成员名(初始值)，成员名(初始值)...

例如

构造函数：
X(int v=0):m(v),r(m){}//意思是：把v赋值给m，再把m赋给r，因为r是引用类型的，因此不能在函数体内构造

3.委托构造函数

就是别人帮你初始化，只要你的参数被包含了

X(int aa,int bb):X(aa,bb,0)//就这一句话就行了，因为他想用的构造函数有三个参数他有两个，所以第三个参数是0，前两个是自己函数的参数再写一遍，

2.析构函数

格式

~account（）；

3.static函数

1）静态成员变量

1.什么意思？satatic成员，所有对象都共享一份数据，有个p1和p2对象，在p1内改变，在p2内调用的时候会发现被改变了

2.特点：编译阶段就分配内存；类内声明类外初始化

访问成员变量可以有两种方式：通过对象，通过类名（person：：成员变量）

#include<stdio.h>
#include<iostream>
using namespace std;
class person
{
public:
	static int a;//类内声明
private:
	static int b;
};
int person::a = 100;//类外初始化
int person::b = 200;
int main()
{
	person p1;
	cout << p1.a << endl;
	person p2;
	p2.a = 200;
	cout << p1.a << endl;//改变p2的值，p1会变化
	cout << p2.b << endl;//这一行会报错因为b是私有的不可访问
}

2）静态成员函数

1.和上面一样，所有 对象共享同一个函数；静态成员函数只能访问静态 成员变量

形式就是给函数名前面加上static

2.静态成员函数里只能对静态成员变量访问，因为非静态成员访问的话根本不知道对谁访问，一开始也不会知道有哪个对象，而静态成员则是共享的，对谁都行

静态成员函数也有访问权限

4.成员变量和成员函数分开存储

1.空对象占用内存空间为1，为了区别对象

2.里面有一个int非静态→4(属于类的·对象上)；静态int类型→4；(不属于类的对象上）

非静态成员函数→4(不属于类对象上，只有1份)；静态成员函数同上；

5.this指针

class person
{
public:
	int age;
	person(int age)
	{
		//this指针用来干嘛？解决名称冲突
		//指向哪里？指向被调用的成员函数所属的对象
		//构造函数被调用，它属于p1，因此this指向p1
		this->age = age;
	}
};
int main()
{
	person p1(20);
	cout << p1.age;
}

 this指针带星号只想本体

#include<stdio.h>
#include<iostream>
using namespace std;
class person
{
public:
	int age;
	person(int age)
	{
		//this指针用来干嘛？解决名称冲突
		//指向哪里？指向被调用的成员函数所属的对象
		//构造函数被调用，它属于p1，因此this指向p1
		this->age = age;
	}
	person& personaddage(person& p)//返回引用可以一直在一个位置操作
	{
		this->age += p.age;
		return *this;//*this返回的是调用的主体
	}
};
int main()
{
	person p1(20);
	person p2(20);
	//cout << p1.age;
	p1.personaddage(p2).personaddage(p2).personaddage(p2);
	cout << p1.age << endl;
}

6.空指针访问成员函数

	void person1() { cout << "this is a person"<<endl; }
	void person2() {
		if (this->age == NULL)return;//加这一行就就不会出错了，加强了程序的健壮性
		cout << age << endl;//这里实际上是this->age;那么p既然是空的，this都没有指的对象，肯定就出错了
	}
};
void test01()
{
	person* p = NULL;
    //下面这两行都是用p这个空指针去访问类内成员，然后去看看函数里的解释
	p->person1();
	p->person2();

}

7.引用：

1.为什么引用传递形参能改变实参呢？

因为形参相当于给原来实参变量起了不同的名字，也就是还是对以前的那个内存操作，因此会改变实参

2.引用作为函数的返回值

就是int &a=test();

（1）普通变量放在堆栈区，放在这里这个函数调用结束空间就会被释放，因此别返回局部变量作为引用；静态变量放在全局区，全局区区上的数据在整个程序结束后释放

（2）左值：就是等号的左边

int &test10()
{
    static int a=10;
    return a;
}
int &ref=test02()
test01()=1000;
cout<<ref<<endl;//返回1000
为什么？
test01返回的就是a的引用，就是a的别名，相当于返回a本身，其实就是a=1000；
而ref2本身就是a的别名

3.引用的本质这里是指针常量

指针常量
int *const b=a;
常量指针
const int *b=a;

记忆方法：原本的int*b这就是对内容固定；把他们拆开，const距离指针近的就是指针常量

4.如果你想让函数无法改变传入的参数，可以将传入的引用参数修改为前面加一个const