【c++】类

1.C语言:面向过程,以函数为核心;
　 C++语言:面向对象,以类为核心;
　
2.类的概念:一类具有相同属性和行为的事物的封装;
　 类的三大特性:封装/继承/多态;
　　　学生:属性(有):姓名/身高/体重等;
　　　　　 行为(能):吃饭/考试/挂科等;
　　　英雄:属性(有):血量/等级/攻击力/钥匙数量等
　　　　 　 行为:移动/打怪/升级等
　　　地图:属性(有):行/列/二级指针;
　　　　　 行为:绘制/初始化/获取内存等;
　　　矩形:属性:坐标/长宽;
　　　　　 行为:求面积/求周长/判断是否相交等;
　　　　　
3.类的定义:(类是一种自定义的数据类型)
　 属性:数据成员; 行为:成员函数;
　 class 类名
　 {
　　 访问权限:
　　 成员1;
　　 成员2;
　　 …
　　 成员n;
　 };//{}和;不能省略
　 注意:.h和.cpp文件(必须同名),
　 一般类的定义(数据成员的定义和成员函数的声明)写在.h中,
　 成员函数的定义写在.cpp中;
　 成员函数的定义
　　　返回值类型 类名::函数名(形参表)
　　　{
　　　　 函数体;
　　　}
　　
　访问权限:
　　public:公有的,可以在类中和类外进行访问;
　　protected:保护的,可以在类中和子类中进行访问;
　　private:私有的,只能在类中访问;(默认)
　　注意:
　　　1.一般数据成员写成私有的,成员函数写成公有的;
　　　2.所有的访问权限不一定全都要写;
　　　3.访问权限可以重复写;
　　类中指哪些地方?
　　　 1.类的作用域限定的函数内
　　　 2.类的定义
　
4.类的内存:
　 1.内存对齐原则
　 2.空类(没有任何数据成员,成员函数不占内存):1个字节
　
5.类的对象:就是类的一个变量;(类名 对象名;)

6.对象访问成员:.(成员选择符)
　 类的指针访问成员:->(成员选择符)
　
7.普通函数与成员函数的区别:
　 1.调用:普通函数直接调用,成员函数必须通过对象调用;
　 2.在成员函数内有默认的指针this(this指针可以省略),this指向调用该函数的对象;
　　Hero hero;
　　hero.pk();//this(Hero*)指向hero
　　Hero* phero = new Hero;
　　phero->pk();//this指向堆区内存
　
8.四大默认成员函数:
　1.构造函数(实际上为对象分配内存)
　　　先分配成员的内存,再执行函数体
　　 无参构造函数写法:
　　　 1.不需要写返回值类型
　　　 2.函数名与类名相同
　　　 3.默认的构造函数没有形参;
　　　 4.构造函数可以重载;
　　 调用情况:创建对象时调用;
　　　 1.Hero hero;//类名 对象名;
　　　 2.new Hero;//new 类名;
　　　 3.new Hero();//new 类名();
　
　　 带参构造函数:
　　　 1.不需要写返回值类型
　　　 2.函数名与类名相同
　　　 3.具有形参表
　 　调用情况:创建对象时传参时调用;
　　　 1.Hero hero(100);//类名 对象名(实参表);
　　　 2.new Hero(100);//new 类名(实参表);
　　　 3.new Hero[3]{实参1,实参2,实参3};//
　
　　成员初始化列表
　　　 1.成员初始化
　　　　 构造函数():成员1(表达式1),成员2(表达式2)
　　　　　　 Vec2::Vec2(float xx, float yy)
　　　　　　　　 :x(xx), y(yy)
　　　 2.调用子对象的带参构造函数
　　　　 构造函数():成员(带参实参表),成员(带参实参表)
　　　　　　 Rect::Rect(float xx, float yy, float w, float h)
　　　　　　　　 :origin(xx, yy), size(w,h)
　　　 3.调用子对象的拷贝构造函数
　　　　　　 Rect::Rect(const Rect& ref)
　　　　　　　　 :origin(ref.origin), size(ref.size)
　　　　　　　　
　　构造函数调用顺序: 虚基类 -> 基类 -> 内嵌成员对象的构造函数 -> 派生类构造函数
　
　2.拷贝构造函数:(将一个对象的值全部拷贝给另一个对象)
　　 写法:
　　　 1.没有返回值类型;
　　　 2.函数名与类名相同;
　　　 3.形参表固定:const 类名& ref;
　　　　　常引用:1.&:防止调用拷贝构造函数,提高效率;
　　　　　　　　2.const:防止通过形参修改实参;
　　　　　注意:什么情况下必须重写拷贝构造函数(深拷贝)?
　　　　　当类的数据成员中有指针时,为了防止指针指向同一段内存.
　
　　调用情况:
　　　 1.用一个类的对象给另一个对象初始化时;
　　　 2.显式调用:Hero hero(hero1);//类名 对象名(另一个对象); 将对象作为构造函数的实参
　　　 3.当函数的形参为类的对象时;//形参 = 实参;
　　　 4.当函数的返回值类型为类的类型时;

３.赋值函数:
　 写法:类名& operator=(const 类名& other);
　　　(用一个类的对象的成员的值给另一个对象一一赋值)
　 调用情况:
　　　 1.用一个类的对象给另一个对象赋值时;
　
４.析构函数:(释放成员的内存)
　 注意:先构造的后析构;
　 　　先执行函数体,再释放成员的内存
　 写法:
　　 1.没有返回值类型;
　　 2.函数名:~类名();
　　 3.无形参,不能重载;
　
　调用情况:回收对象的内存时;
　　1.被系统自动回收;
　　2.delete;

A.h
#pragma once
#include "B.h"
class CA
{
public:
	CA(char* name = "***");
	CA(const CA& ref);
	CA& operator=(const CA& other);
	~CA();//析构函数
private:
	CB cb;
	char name[20];
};


A.cpp
#include "A.h"
//#include "B.h"
#include <iostream>
using namespace std;
CA::CA(char* name)
//先分配成员的内存,再执行函数体
{
	CB cb1;
	strcpy_s(this->name, name);
	//cout <<"name:" <<name << endl;
	//CB cb;
	cout << "调用了"<<this->name<<"的构造函数" << endl;
}
CA::CA(const CA& ref)
{
	strcpy_s(this->name, ref.name);
	cout << "调用了" << this->name << "的拷贝构造函数" << endl;
}

CA& CA::operator=(const CA& other)
{
	strcpy_s(this->name, other.name);
	cout << "调用了"<<this->name<<"的赋值函数" << endl;
	return *this;//返回当前对象
}

CA::~CA()//析构函数的定义
{
	//cout << "name:" << name << endl;
	cout << "调用了"<<this->name<<"的析构函数" << endl;
}
//先执行函数体,再释放成员的内存

/
	/*CB的构造-CA的构造-CA的析构-CB的析构*///(在CA构造函数中没有局部变量cb1时)
	//CB的构造-CB的构造-CA的构造-CB的析构(局部变量)-CA的析构-CB的析构(构造函数里的那个)
	CA ca;//