1.引用的概念(对某个变量的引用，等价于这个变量，相当于这个变量的别名)
#include <iostream>

using namespace std;

int main()
{
    int n = 7;
    int &r = n; // r引用了n，r的类型是int &

    r = 4;
    cout << r << endl; // 4
    cout << n << endl; // 4
    n = 5;
    cout << r; // 5
}
【注】
①定义引用时，一定要将其初始化成引用某个变量（只能引用变量）
②初始化后，它就一直引用该变量，，不会再引用其他变量了

定义常量指针
①不可以通过常量指针修改其指向的内容
const int *p = &n;
*p = 5; // 编译出错

②不能把常量指针赋给非常量指针。反过来可以
const int *p1;
int *p2;
p1 = p2; // ok
p2 = p1; // error

用new运算符实现动态内存分配
（1）
P = new T;
其中T为任意的类型名，P是类型为T*的指针（返回值的类型为T*）
动态分配一片大小为sizeof(T)的内存空间，并将该内存的起始地址赋给P

（2）
P = new T[N];
T:任意类型名
P：类型为T*的指针（返回值的类型为T*）
N：要分配的元素的个数
动态分配一片大小为N * sizeof(T)的内存空间，并将该内存的起始地址赋给P

用delete运算符释放动态分配的内存
(1)
格式：delete 指针;

int *p = new int;
*p = 5;
delete p;

(2)释放动态分配的数组
格式：delete []指针;

int *p = new int[20];
p[0] = 1;
delete []p;

面向对象程序设计方法：
1.将各类客观事物的共同特点（属性）归纳出来，形成一种可以用多个变量描述事物属性的数据结构
2.将这类事物所能进行的行为也归纳出来，“抽象”成一个个的函数
3.将数据结构和操作这些数据结构的函数捆绑起来，“封装”成一个个类
【注】类和类之间可以互相使用对方的成员函数


类和对象：
1.从客观事物中抽象出一个类

class CRectangle // 类
{
    public:
        int w, h; // 属性
        // 函数
        int Area()
        {
            return w * h;
        }
        int Perimeter()
        {
            return 2 * (w + h);
        }
        void Init(int w_, int h_)
        {
            w = w_, h = h_;
        }
}

int main()
{
    int w,h;
    CRectangle r; // r是一个对象（用类定义出来的变量即为对象）
    cin >> w >> h;

    r.Init(w, h); // 用于定义对象r的w和h
    cout << r.Area() << " " << r.PerPerimeter() << endl;

    return 0;
}

对象的内存分配
和结构体变量一致，对象所占用的存储空间，等于其所有成员变量的大小之和
但是同一个类所定义的对象的某个成员变量被改变了，不会影响到另一个对象！

如何定义对象的某个成员函数？
法1：对象名.成员名
CRectangle r1, r2;
r1.w = 5;
r2.Init(5,4);

法2：指针->成员名
CRectangle r1, r2;
CRectangle *p1 = &r1;
CRectangle *p2 = &r2;
p1->w = 5;
p2->Init(5,4);

类成员的可访问范围
public:公有成员（属性or函数），可以在任何地方访问
private:私有成员（属性or函数），只能在成员函数内访问

【注】若在类的某个成员之前没有限定上述关键字，则默认的认为是私有成员

成员函数也可以重载，而且可以带有缺省的参数