C++_基础_类和对象

内容：

(1)引用
(2)类型转换
(3)C++社区给C程序员的建议
(4)面向对象编程的概念
(5)类和对象
(6)构造函数
(7)初始化列表及其必要性

1.引用
1.1 指针和引用的使用说明
(1)指针中*的停靠问题
int* pi;
int * pi;
int *pi;// 效果都是一样的

不成文的规则：
如果定义一个指针变量时，习惯上让*停靠在数据类型的那边;如果定义多个指针变量时，习惯上让*停靠在变量名的那边
如：
int* pi;
int *pi,*pj;

(2)引用中&的停靠问题
int& b = a;
int & b = a;
int &b = a;//效果一样

int& b = a;
int &m = a,&n = b;//同上

(3)起别名的方式去使用
typedef int* PINT;
typedef int& RINT;
PINT i,j; //两个指针 (避免了Int *p,q,定义一个指针一个整型的情况)
RINT m = a,n = b; //两个引用

1.2 扩展(指针和引用的区别)
(1)可以定义指向指针的指针，但是不可以定义指向引用的指针
如：
int a = 10;
int* pa = &a;//一级指针
int** ppa = &pa;//二级指针

int& b = a;//a起别名为b
int& *pb = &b; //error

(2)可以定义引用指针的引用，不可以定义引用 引用的引用
如：
int a = 10;
int* pa = &a;
int* &ra = pa; //ok

int& b = a;
int&& rb = b; // error

(3)可以声明指针数组，不可以声明引用型数组，但是可以声明数组的引用
如：
int* pa[5]; //指针数组
int& pa[5];// error

int (*pa)[5];//数组指针
int (&pa)[5];//数组引用

1.3 引用作为函数的参数(使用引用的好处)
(1)使用引用型参数可以在函数中对实参变量的值进行修改
(2)使用引用型参数可以避免参数在传递过程中发生数据内容的拷贝
(3)通过将参数定义为常引用，防止在函数体内对实参的意外修改，同时还可以接受常量型实参
(4)引用作为函数的形参实际上就是址传递

建议：
对于函数的参数来说，尽量加&，尽量加const,一般用于自定义数据类型

练习：
分别使用int类型变量、指针以及引用作为函数的参数，来交换两个实参变量的值

1.4 引用作为函数的返回值
永远不要返回对局部变量(包括函数的形参)的引用,可以返回 静态局部变量/全局变量/动态内存/实参的引用/成员变量 的引用,这些返回值都是安全的

2.类型转换
隐式类型转换： 一般从小 -> 大
显式类型转换(强制类型转换): 一般从大到小的转换

如：
char c ;
int i = (int)c; //C语言风格
int i = int(c); //C++风格

(1)静态类型转换
目标类型 变量名 =
static_cast<目标类型>(源类型变量);

功能：
如果在目标类型和源类型之间只要有一个方向上可以做隐式类型转换，那么在两个方向上都可以做静态类型转换；反之，如果在两个方向上都不能做隐式类型转换，那么在两个方向上都不能做静态类型转换

(2)常量类型转换
目标类型 变量名 =
const_cast<目标类型>(源类型变量);

功能：
主要用于去除指针/引用上的常属性

注意：
试图通过const_cast去修改一个常量的值，那么后果是不确定的

(3)重解释类型转换
目标类型 变量名 =
reinterpret_cast<目标类型>(源类型变量名);

功能：
主要用于任意两种指针类型之间的转换，以及指针和整型之间的转换

(4)动态类型转换
目标类型 变量名 =
dynamic_cast<目标类型>(源类型变量名);

功能：
主要用于具有多态特性的父子类 指针/引用 之间的转换(以后讲到)

3.C++社区对C程序员的建议
(1)尽量少使用宏，而代之以 const 和 enum 以及 inline替代之
如：
#define PI 3.14
const double pi = 3.14;

#define MAX(x,y) (x)>(y)?(x):(y)
inline int max(int x,int y)
{
return x>y?x:y;
}

(2)变量随使用随声明
(3)不用malloc/free 而用new/delete
(4)避免使用void*、指针算数、联合以及强制类型转换
(5)尽量少使用C风格字符串，代之以string对象
strcpy/strcmp/strcat/...
(6)理解面向对象的编程思想

4.面向对象编程的初识
4.1 什么是对象？
万物皆对象，无论是任何对象，都可以去分析它的属性以及行为

4.2 什么是面向对象？
以属性和行为的观点去分析现实世界的事物的方式 叫 面向对象
面向对象 -> 大处着眼
面向过程 -> 关注的整个过程的细节

4.3 什么是面向对象编程？
先采用面向对象的思想去分析，然后采用面向对象的编程语言把分析出来的方法表达出来

4.4 为什么需要面向对象编程？
软件产业化发展的需求

5.类和对象
把对象的共性提取出来就组成类
如：

学生类:
属性：姓名 年龄 性别 学号
行为：吃饭 学习 娱乐
教师类：
属性：姓名 年龄 性别 职称
行为：吃饭 授课 娱乐

采用C++语法形式将上述过程描述出来就叫面向对象编程

5.1 类的定义
格式：
class 类名{};
如：
class Student{};

5.2 成员变量(属性)
格式：
class 类名
{
数据类型 成员变量名;
...
};
如：
class Student
{
string m_name;//姓名
int m_age; //年龄
};

5.3 成员函数(行为)
格式：
class 类名
{
返回值类型 函数名(形参表)
{
成员函数体;
}
};
如：
class Student
{
string m_name;
int m_age;

void learn(const string& lesson){ ... }
};

5.4 访控属性
(1)public 公有的
(2)protected 保护的
(3)private 私有的

访问限定符 访控属性 本类 子类 类外
---------------------------------
public 公有的 ok ok ok
protected 保护的 ok ok no
private 私有的 ok no no

结构体和类的区别：
(1)关键字不同
(2)类中默认访控属性是私有的，而结 构体中默认访控属性是公有的

6.构造函数
函数名与类名相同，函数没有返回值类型(连void都没有)的函数叫构造函数

格式：
class 类名
{
类名(形参表)
{
构造函数体;
}
};

注意：
当对象被创建时构造函数会被自动调用，一般用于对对象进行初始化,也就是给对象的成员变量进行初始化

/////////////////////////////////////////////////////////////////////

1.引用

　　-为什么要有引用？

　　-引用的底层实现是什么？

　　-引用的使用场景？

　　-引用和指针的区别？(从本质上相区别)

　　-使用引用的注意点？

2.类型转换

　　-用的比较少，举几个例子知道作用就ok了

3.面向对象

　　-为什么要有面向对象？

　　-面向对象和面向过程有什么区别？

　　　　-解决问题的思路和方法不一样

　　-构造函数

　　　　-对象的初始化为什么要采用构造函数？

　　　　-类这个类型，在底层是怎么样实现的？

　　　　-类的内存是怎样分配的？

　　　　-类的访问控制属性为什么要存在？