开发成长之路（6）– C++从入门到开发（C++入门不难）

数组的动态内存分配
• 对象的动态内存分配

这个图有点偏差啊，C++是要排在QT之前的，回头我会对这个图进行一波的微调。

这已经是进入了第二个阶段了，此前如果C语言基础还没有打好的小伙伴可以再补一下C语言：
开发成长之路（1）– C语言从入门到开发（入门篇一）
开发成长之路（2）– C语言从入门到开发（函数与定制输入输出控制函数）
开发成长之路（3）– C语言从入门到开发（讲明白指针和引用，链表很难吗？）
开发成长之路（4）– C语言从入门到开发（距离开发，还差这一篇）
开发成长之路（5）– C语言从入门到开发（仿ATM机项目，我写的第一个项目）

C++背景介绍：C++入门真的不难

C++和C经常被放在一起写，这难道还需要我再解释什么吗？
C/C++。

C++，在C语言的基础上增添了新的特性，主要为类。
其实类也是源自于对C语言结构体的发扬光大。正因为有了类的出现，C++带有着强的封装性、继承性、多态性。
而后其它的一切，都是由于这些特性而做的二次开发，从而在发展的道路上一骑绝尘。

大家觉得C++难，也就是难在这些后继发展的内容上吧。
这个阶段，让我们忘掉那些，探求最简单的C++基本语法！！！

C++语言与C语言的异同

1、编码规范
在C++中引用的头文件和C中的头文件不太一样，但是这并不妨碍二者互用，兼容的。
C里面的输入输出头为：

include<iostream>using namespace std;	//这一行意为使用名空间std，std里面包含了很多东西

2、标准输入与输出
在C++里面，输入输出没那么的麻烦，

cin>>输入内容>>代码>>继续输入;cout<<输出内容<<代码<<继续输出;

3、字符串。
C++中有专门的字符串类。

#include <string>using namespace std;

支持的方法有：

4、类，后面细讲

类

整张图来看的明白（源自菜鸟编程）：

其他的不必讲了吧，讲一下那个变量和方法、访问修饰符。

类方法

变量，称为类的属性。函数，称为类的方法。

我们来一个实际的例子看一下：

class Box{public:double length;      // 长度double breadth;     // 宽度double height;      // 高度double getVolume(void){return length * breadth * height;}};

也可以在类的外部使用范围解析运算符 :: 定义该函数

double Box::getVolume(void){return length * breadth * height;}

值得注意的是，在分文件写代码的时候，需要将类及类方法声明在.h文件中，而类方法的实现放在.cpp文件中，这时候就需要下面的写法了。

初始化类对象，并调用成员函数的方法：

Box myBox;          // 创建一个对象myBox.getVolume();  // 调用该对象的成员函数

或：

Box *myBox = new Box();          // 创建一个对象myBox0->getVolume();  // 调用该对象的成员函数

C++ 类访问修饰符

类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。

为什么说C++有很强的封装性呢，就是因为这三个类访问修饰符。
且看下去：

class Base {public:// 公有成员，可以在类外被随意访问protected:// 受保护成员，受保护继承的子类可以使用，自己和友元也可以使用private:// 私有成员，只能在本类内使用，友元函数也行};

我们一般将某些必须开放的接口设置为公有，有些看情况设置为保护，其余一律设为私有。
类的属性不建议公有！！！

示例：

class Box{public:void setWidth( double wid );double getWidth( void );private:double length;double width;};// 成员函数定义double Box::getWidth(void){return width ;}void Box::setWidth( double wid ){width = wid;}

类继承

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

可以看出，private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；protected 成员可以被派生类访问。

示例：

class A{public:int a;A(){a1 = 1;a2 = 2;a3 = 3;}void fun(){cout << a1 << endl;   //正确cout << a2 << endl;   //正确cout << a3 << endl;   //正确}public:int a1;protected:int a2;private:int a3;};class B : public A{public:int a;B(int i){A();a = i;}void fun(){cout << a << endl;       //正确，public成员cout << a1 << endl;       //正确，基类的public成员，在派生类中仍是public成员。cout << a2 << endl;       //正确，基类的protected成员，在派生类中仍是protected可以被派生类访问。cout << a3 << endl;       //错误，基类的private成员不能被派生类访问。}};

构造/析构函数

在初始化类的对象的时候会需要用到类的构造函数，构造函数的名称与类的名称是完全相同的，并且不会返回任何类型、

构造函数可用于为某些成员变量设置初始值。

来看个例子：

class Line{public:Line();  // 这是构造函数};// 成员函数定义，包括构造函数Line::Line(void){cout << \"Object is being created\" << endl;}

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。

像这样：

class Line{public:Line(double len);  // 这是构造函数private:double length;};// 成员函数定义，包括构造函数Line::Line( double len){cout << \"Object is being created, length = \" << len << endl;length = len;}

还可以这样：

Line::Line( double len): length(len){cout << \"Object is being created, length = \" << len << endl;}

看个人喜好了。

析构函数呢，相对比较简单，但是也是有坑在里面的。

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
一般用于程序员手动回收内存。

class Line{public:Line();   // 这是构造函数声明~Line();  // 这是析构函数声明};// 成员函数定义，包括构造函数Line::Line(void){cout << \"Object is being created\" << endl;}Line::~Line(void){cout << \"Object is being deleted\" << endl;}

拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。

class Line{public:Line( int len );             // 简单的构造函数Line( const Line &obj);      // 拷贝构造函数~Line();                     // 析构函数private:int *ptr;};// 成员函数定义，包括构造函数Line::Line(int len){cout << \"调用构造函数\" << endl;// 为指针分配内存ptr = new int;*ptr = len;}Line::Line(const Line &obj){cout << \"调用拷贝构造函数并为指针 ptr 分配内存\" << endl;ptr = new int;*ptr = *obj.ptr; // 拷贝值}

this指针

this指针存在于类中，指代的是这个类本身的意思。
其实我也想不出来太多它必须存在的场景，碧如说：参数名和类属性名一样的时候，或者函数指针参数名和类方法名一样的时候吧。

反正看到this的时候不要大惊小怪就好啦。

关于类，大致讲到这里。

C++ 动态内存

了解一下堆栈：

栈：在函数内部声明的所有变量都将占用栈内存。堆：这是程序中未使用的内存，在程序运行时可用于动态分配内存。

使用 new 运算符来为任意的数据类型动态分配内存的通用语法：

new data-type;

使用 delete 操作符释放它所占用的内存：

delete pvalue;        // 释放 pvalue 所指向的内存

示例：

double* pvalue  = NULL; // 初始化为 null 的指针pvalue  = new double;   // 为变量请求内存balabaladelete pvalue;        // 释放 pvalue 所指向的内存

数组的动态内存分配

直接上手吧：

char* pvalue  = NULL;   // 初始化为 null 的指针pvalue  = new char[20]; // 为变量请求内存delete [] pvalue;        // 删除 pvalue 所指向的数组

对象的动态内存分配

int main( ){Box* myBoxArray = new Box();delete myBoxArray;return 0;}

先到这里啦，我还有点事情。