C++类的封装及相关学习（一）

const相关内容

const与指针类型的表示

const int *p = NULL;
int const *p = NULL;//这两个是完全等价的
const int*const p = NULL;
int const*const p = NULL;//这两个是完全等价的

其中可用以下等式来描述:
int x = 3; const int *p = &x;
p = &y;这是正确的 *p = 4;这是错误的

变量名	储存地址	储存内容
X	&X	3
p	&p	&x

同时可描述以下等式:
int x = 3;int *const p = &x;
p = &y;这是错误的

变量名	存储地址	储存内容
x	&x	3
p	&p	&x(不可变)

同时可描述以下等式：
const int x = 3; const int const p = &x;
p = &y;p = 4;都是错误的

变量名	存储地址	存储内容
x	&x	3(不可变)
p	&p	&x(不可变)

const与引用的关系

定义如下所示：
int x = 3; const int &y = x;
x = 10;正确的 y = 20;是错误的

变量名	存储地址	存储内容
x	&x	3

函数参数默认值

• 在经过确认，函数在声明的时候可以给定义值，在定义的时候不用给默认值

void fun(int i,int j = 5,int k = 10);
void fun(int i,int j,int k)
{
    cout << i << j << k;
}

在没有实参的时候就使用默认值，在有实参的时候则使用传入的值

函数的重载

• 在相同作用域下：用同一函数名定义的多个函数，参数个数和类型不相同

int getMax(int x,int y,int z)
{
    //to do
}
double getMax(double x,double y,double z)
{
    //to do
}

内联函数

• 编译时将函数代码和实参代替函数调用语句

inline int max(int a,int b,int c);
int main()
{
    int i = 10,j = 20,k = 30,m;
    m = max(i,j,k);
}

• 内联编译是建议性的，由编译器决定
• 逻辑必须简单，不能包含for这些
• 递归函数不能内联

内存申请和释放

• 申请内存:new 释放内存:delete

//申请内存
int *p = new int;
//释放内存
delete p;

• 如何申请一块内存

int *arr = new int[10];//申请块内存
delete []arr;//释放内存

• 申请内存不一定成功则

int *p = new int[1000];
if(NULL == p)
{
    //内存申请失败
}

• 最后要把内存的指针置位null

类与对象

类相关的定义

• 访问限定符：public(公共的)、protected(受保护的)、private(私有的)

拷贝构造函数

• 在对类进行拷贝的时候会调用拷贝构造函数而不会调用构造函数

class Student
{
    public:
        Student(){m_strName = "Jim";}
        Student(const Student& stu){}//拷贝构造函数
    private:
        string m_strName;
};

析构函数

• 归还资源，销毁内存，不能重载，调用函数

//定义格式：~类名()
class Student()
{
public:
    Student(){ cout << "Student" << endl;}
    ~Student(){ cout << "~Student" << endl;}
private:
    string m_strName;
}

• 不允许加任何参数ed

总结

• 类 = 成员函数 + 数据成员(自己定义命名空间)
• • 数据成员 = 普通数据成员 + string + const成员 + 静态数据成员
• • 成员函数 = 属性封装函数（set函数和get函数） + 一般函数 + 特殊函数（构造函数【拷贝构造+默认构造】 + 析构函数）
• 对象的实例化 = 栈中实例化 + 堆中实例化 + 引用？ + const？