引用和指针用法的区别。

引用和指针功能一样，引用必须要初始化，赋值nullptr。

int &ra = a；

引用只能指向一个地址，而指针可以变化自己的指向地址。

纯虚函数只可以被继承。

将父类的析构函数声明为虚函数，作用是用父类的指针删除一个派生类对象时，派生类对象的析构函数会被调用。例如：

class Staff
{
public:
   std::string name;
   int age;

   virtual ~Staff()
   {

   }
}

class Coder : public Staff
{
public:
   std::string language;

   virtual ~Coder()
   {

   }
};

int main(int argc,char **argv)
{
   Staff * s = new Coder();

   delete s;

   return 0;
}

此时如果析构函数不加 virtual，那么 delete 父类指针的时候，子类的析构就不会被调用，某些情况下会导致内存泄漏。

纯虚函数只可以被继承。

将父类的析构函数声明为虚函数，作用是用父类的指针删除一个派生类对象时，派生类对象的析构函数会被调用。例如：

class Staff
{
public:
   std::string name;
   int age;

   virtual ~Staff()
   {

   }
}

class Coder : public Staff
{
public:
   std::string language;

   virtual ~Coder()
   {

   }
};

int main(int argc,char **argv)
{
   Staff * s = new Coder();

   delete s;

   return 0;
}

此时如果析构函数不加 virtual，那么 delete 父类指针的时候，子类的析构就不会被调用，某些情况下会导致内存泄漏。

给员工分部门：类的继承

类，就像是对某一类事物的抽象模版，我们可以根据这个模版生产出具有相同属性的对象。例如，我们之前将员工抽象成了 Staff 类。

而在某些场景下，我们希望对抽象的内容进行扩增，或者说更加具体化。例如，我们之前定义了员工，但是员工只是很抽象的一个概念，员工和员工是不一样的，例如，程序员和会计都是员工，他们都具有员工应有的属性，但是除此之外，他们还有额外属于自己的东西。

为了完成这种关系，我们来学习一下继承。

例如，我们可以来写一个程序员类，名字叫做 Coder

class Coder { };

这个 Coder 是员工的一种，他具有员工的所有属性，所以，我们可以让 Coder 继承自 Staff

class Coder : public Staff { };

当然，除了具有 Staff 的所有内容之外，Coder 还有属于自己的动作，那就是写代码，我们就可以这样写：

class Coder : public Staff { public:     void code()     {         printf("Coding!!!\n");     } };

这样，Coder 这个类，除了具有 Staff 的所有成员变量和成员函数之外，还有了一个属于自己的函数。

类

类，是 C++ 实现面向对象最基础的部分。类其实和之前学过的结构体十分相似，你可以认为类是结构体的升级版。

类的申明

在 C++ 中，可以用下面的代码申明一个员工类：

class Staff { };

可以像使用结构体一样使用这个类：

#include <stdio.h> class Staff { }; int main(int argc,char **argv) {     Staff st;     return 0; }

分文件编程

我们在此之前都是把代码放到一个文件里，但是这样在实际工程中肯定是不行的，我们不可能把所有的代码都写到一个文件夹里面。而在 C++ 中我们就常常把类定义到不同的文件里面，把每个类都独立起来，这样代码的耦合性就会降低，方便维护。

在 C++ 中，我们可以把一个类写到两个文件里面，一个是后缀为 .h 或者 .hpp 的头文件，一个是后缀为 .cpp 的实现文件。我们先在开发环境里新建一个类。输入类名是 Staff。

可以看到 VS 为我们创建类两个文件，Staff.h 和 Staff.cpp。Staff.h 文件为定义，Staff.cpp 为实现。

在分了文件之后，我们想要在 main 函数中引用这个类，就需要使用 #include “Staff.h” 将头文件引入进来。

实例化

在新建了一个类之后，我们就可以根据这个类产生对象了。根据类产生对象的过程叫做实例化。

#include "Staff.h" 

int main(int argc,char **argv) 

{     // 我们就这样实例化了三个员工     

Staff st1;     

Staff st2;     

Staff st3;    

return 0; 

}

这样分配，我们将这三个“员工”分配到了栈上，同样的，可以把他们分配到堆内存上面去。

new delete

要将对象分配到堆上，需要用到另外两个关键字，new 和 delete。new 用来分配对象，delete 用来删除对象。new 会返回一个指针，在使用完毕后，要通过 delete 把这个指针指向的地址释放掉。

#include "Staff.h" 

int main(int argc,char **argv) {    

Staff * st1 = new Staff();     

Staff * st2 = new Staff();     

Staff * st3 = new Staff();     

// 记得释放    

 delete st1;     

delete st2;     

delete st3;     

return 0;

 }

霸道总裁的员工：类

我们上一小节中介绍了面向对象的思想，这一小节开始，我们来具体看看在 C++ 中应该如何实现面向对象。

类

类，是 C++ 实现面向对象最基础的部分。类其实和之前学过的结构体十分相似，你可以认为类是结构体的升级版。

类的申明

在 C++ 中，可以用下面的代码申明一个员工类：

class Staff { };

可以像使用结构体一样使用这个类：

#include <stdio.h> class Staff { }; int main(int argc,char **argv) {     Staff st;     return 0; }

分文件编程

我们在此之前都是把代码放到一个文件里，但是这样在实际工程中肯定是不行的，我们不可能把所有的代码都写到一个文件夹里面。而在 C++ 中我们就常常把类定义到不同的文件里面，把每个类都独立起来，这样代码的耦合性就会降低，方便维护。

在 C++ 中，我们可以把一个类写到两个文件里面，一个是后缀为 .h 或者 .hpp 的头文件，一个是后缀为 .cpp 的实现文件。我们先在开发环境里新建一个类。输入类名是 Staff。

可以看到 VS 为我们创建类两个文件，Staff.h 和 Staff.cpp。Staff.h 文件为定义，Staff.cpp 为实现。

在分了文件之后，我们想要在 main 函数中引用这个类，就需要使用 #include “Staff.h” 将头文件引入进来。

实例化

在新建了一个类之后，我们就可以根据这个类产生对象了。根据类产生对象的过程叫做实例化。

#include "Staff.h" 

int main(int argc,char **argv) 

{     // 我们就这样实例化了三个员工     

Staff st1;     

Staff st2;     

Staff st3;    

return 0; 

}

这样分配，我们将这三个“员工”分配到了栈上，同样的，可以把他们分配到堆内存上面去。

new delete

要将对象分配到堆上，需要用到另外两个关键字，new 和 delete。new 用来分配对象，delete 用来删除对象。new 会返回一个指针，在使用完毕后，要通过 delete 把这个指针指向的地址释放掉。

#include "Staff.h" 

int main(int argc,char **argv) {    

Staff * st1 = new Staff();     

Staff * st2 = new Staff();     

Staff * st3 = new Staff();     

// 记得释放    

 delete st1;     

delete st2;     

delete st3;     

return 0;

 }

霸道总裁的员工：类

我们上一小节中介绍了面向对象的思想，这一小节开始，我们来具体看看在 C++ 中应该如何实现面向对象。

类

类，是 C++ 实现面向对象最基础的部分。类其实和之前学过的结构体十分相似，你可以认为类是结构体的升级版。

类的申明

在 C++ 中，可以用下面的代码申明一个员工类：

class Staff { };

可以像使用结构体一样使用这个类：

#include <stdio.h> class Staff { }; int main(int argc,char **argv) {     Staff st;     return 0; }

分文件编程

我们在此之前都是把代码放到一个文件里，但是这样在实际工程中肯定是不行的，我们不可能把所有的代码都写到一个文件夹里面。而在 C++ 中我们就常常把类定义到不同的文件里面，把每个类都独立起来，这样代码的耦合性就会降低，方便维护。

在 C++ 中，我们可以把一个类写到两个文件里面，一个是后缀为 .h 或者 .hpp 的头文件，一个是后缀为 .cpp 的实现文件。我们先在开发环境里新建一个类。输入类名是 Staff。

可以看到 VS 为我们创建类两个文件，Staff.h 和 Staff.cpp。Staff.h 文件为定义，Staff.cpp 为实现。

在分了文件之后，我们想要在 main 函数中引用这个类，就需要使用 #include “Staff.h” 将头文件引入进来。

实例化

在新建了一个类之后，我们就可以根据这个类产生对象了。根据类产生对象的过程叫做实例化。

#include "Staff.h" int main(int argc,char **argv) {     // 我们就这样实例化了三个员工     Staff st1;     Staff st2;     Staff st3;     return 0; }

这样分配，我们将这三个“员工”分配到了栈上，同样的，可以把他们分配到堆内存上面去。

new delete

要将对象分配到堆上，需要用到另外两个关键字，new 和 delete。new 用来分配对象，delete 用来删除对象。new 会返回一个指针，在使用完毕后，要通过 delete 把这个指针指向的地址释放掉。

#include "Staff.h" 

int main(int argc,char **argv) {    

Staff * st1 = new Staff();     

Staff * st2 = new Staff();     

Staff * st3 = new Staff();     

// 记得释放    

 delete st1;     

delete st2;     

delete st3;     

return 0;

 }

霸道总裁的员工：类

我们上一小节中介绍了面向对象的思想，这一小节开始，我们来具体看看在 C++ 中应该如何实现面向对象。

类

类，是 C++ 实现面向对象最基础的部分。类其实和之前学过的结构体十分相似，你可以认为类是结构体的升级版。

类的申明

在 C++ 中，可以用下面的代码申明一个员工类：

class Staff { };

可以像使用结构体一样使用这个类：

#include <stdio.h> class Staff { }; int main(int argc,char **argv) {     Staff st;     return 0; }

分文件编程

我们在此之前都是把代码放到一个文件里，但是这样在实际工程中肯定是不行的，我们不可能把所有的代码都写到一个文件夹里面。而在 C++ 中我们就常常把类定义到不同的文件里面，把每个类都独立起来，这样代码的耦合性就会降低，方便维护。

在 C++ 中，我们可以把一个类写到两个文件里面，一个是后缀为 .h 或者 .hpp 的头文件，一个是后缀为 .cpp 的实现文件。我们先在开发环境里新建一个类。输入类名是 Staff。

可以看到 VS 为我们创建类两个文件，Staff.h 和 Staff.cpp。Staff.h 文件为定义，Staff.cpp 为实现。

在分了文件之后，我们想要在 main 函数中引用这个类，就需要使用 #include “Staff.h” 将头文件引入进来。

实例化

在新建了一个类之后，我们就可以根据这个类产生对象了。根据类产生对象的过程叫做实例化。这个过程就像是公司招聘员工一样，幸运的是，我们作为程序的老板，并不需要和现实中一样去张贴招聘启示。在 C++ 中，“招聘“员工，只需要用以下的代码就可以了。

#include "Staff.h" int main(int argc,char **argv) {     // 我们就这样实例化了三个员工     Staff st1;     Staff st2;     Staff st3;     return 0; }

这样分配，我们将这三个“员工”分配到了栈上，同样的，可以把他们分配到堆内存上面去。

new delete

要将对象分配到堆上，需要用到另外两个关键字，new 和 delete。new 用来分配对象，delete 用来删除对象。new 会返回一个指针，在使用完毕后，要通过 delete 把这个指针指向的地址释放掉。

#include "Staff.h" int main(int argc,char **argv) {     // 我们就这样实例化了三个员工     Staff * st1 = new Staff();     Staff * st2 = new Staff();     Staff * st3 = new Staff();     // 记得释放     delete st1;     delete st2;     delete st3;     return 0; }

霸道总裁的员工：类

我们上一小节中介绍了面向对象的思想，这一小节开始，我们来具体看看在 C++ 中应该如何实现面向对象。

类

类，是 C++ 实现面向对象最基础的部分。类其实和之前学过的结构体十分相似，你可以认为类是结构体的升级版。之后的学习中你会更加理解类。现在，我们只简单得来介绍一下类。

类的申明

在 C++ 中，可以用下面的代码申明一个员工类：

class Staff { };

可以像使用结构体一样使用这个类：

#include <stdio.h> class Staff { }; int main(int argc,char **argv) {     Staff st;     return 0; }

分文件编程

我们在此之前都是把代码放到一个文件里，但是这样在实际工程中肯定是不行的，我们不可能把所有的代码都写到一个文件夹里面。而在 C++ 中我们就常常把类定义到不同的文件里面，把每个类都独立起来，这样代码的耦合性就会降低，方便维护。

在 C++ 中，我们可以把一个类写到两个文件里面，一个是后缀为 .h 或者 .hpp 的头文件，一个是后缀为 .cpp 的实现文件。我们先在开发环境里新建一个类。输入类名是 Staff。

可以看到 VS 为我们创建类两个文件，Staff.h 和 Staff.cpp。Staff.h 文件为定义，Staff.cpp 为实现。

在分了文件之后，我们想要在 main 函数中引用这个类，就需要使用 #include “Staff.h” 将头文件引入进来。

实例化

在新建了一个类之后，我们就可以根据这个类产生对象了。根据类产生对象的过程叫做实例化。这个过程就像是公司招聘员工一样，幸运的是，我们作为程序的老板，并不需要和现实中一样去张贴招聘启示。在 C++ 中，“招聘“员工，只需要用以下的代码就可以了。

#include "Staff.h" int main(int argc,char **argv) {     // 我们就这样实例化了三个员工     Staff st1;     Staff st2;     Staff st3;     return 0; }

这样分配，我们将这三个“员工”分配到了栈上，同样的，可以把他们分配到堆内存上面去。

new delete

要将对象分配到堆上，需要用到另外两个关键字，new 和 delete。new 用来分配对象，delete 用来删除对象。new 会返回一个指针，在使用完毕后，要通过 delete 把这个指针指向的地址释放掉。

#include "Staff.h" int main(int argc,char **argv) {     // 我们就这样实例化了三个员工     Staff * st1 = new Staff();     Staff * st2 = new Staff();     Staff * st3 = new Staff();     // 记得释放     delete st1;     delete st2;     delete st3;     return 0; }

霸道总裁的员工：类

我们上一小节中介绍了面向对象的思想，这一小节开始，我们来具体看看在 C++ 中应该如何实现面向对象。

类

类，是 C++ 实现面向对象最基础的部分。类其实和之前学过的结构体十分相似，你可以认为类是结构体的升级版。之后的学习中你会更加理解类。现在，我们只简单得来介绍一下类。

类的申明

在 C++ 中，可以用下面的代码申明一个员工类：

class Staff { };

可以像使用结构体一样使用这个类：

#include <stdio.h> class Staff { }; int main(int argc,char **argv) {     Staff st;     return 0; }

分文件编程

我们在此之前都是把代码放到一个文件里，但是这样在实际工程中肯定是不行的，我们不可能把所有的代码都写到一个文件夹里面。而在 C++ 中我们就常常把类定义到不同的文件里面，把每个类都独立起来，这样代码的耦合性就会降低，方便维护。

在 C++ 中，我们可以把一个类写到两个文件里面，一个是后缀为 .h 或者 .hpp 的头文件，一个是后缀为 .cpp 的实现文件。我们先在开发环境里新建一个类。输入类名是 Staff。

可以看到 VS 为我们创建类两个文件，Staff.h 和 Staff.cpp。Staff.h 文件为定义，Staff.cpp 为实现。

在分了文件之后，我们想要在 main 函数中引用这个类，就需要使用 #include “Staff.h” 将头文件引入进来。

实例化

在新建了一个类之后，我们就可以根据这个类产生对象了。根据类产生对象的过程叫做实例化。这个过程就像是公司招聘员工一样，幸运的是，我们作为程序的老板，并不需要和现实中一样去张贴招聘启示。在 C++ 中，“招聘“员工，只需要用以下的代码就可以了。

#include "Staff.h" int main(int argc,char **argv) {     // 我们就这样实例化了三个员工     Staff st1;     Staff st2;     Staff st3;     return 0; }

这样分配，我们将这三个“员工”分配到了栈上，同样的，可以把他们分配到堆内存上面去。

new delete

要将对象分配到堆上，需要用到另外两个关键字，new 和 delete。new 用来分配对象，delete 用来删除对象。new 会返回一个指针，在使用完毕后，要通过 delete 把这个指针指向的地址释放掉。

#include "Staff.h" int main(int argc,char **argv) {     // 我们就这样实例化了三个员工     Staff * st1 = new Staff();     Staff * st2 = new Staff();     Staff * st3 = new Staff();     // 记得释放     delete st1;     delete st2;     delete st3;     return 0; }

指针变量其实和普通变量没有什么区别，一个函数也是可以正常返回一个指针的。

char * func()
{
   char * p = nullptr;
   return p;
}

int main(int argc,char **argv)
{
   return 0;
}

但是我们需要思考的是，什么情况下我们要返回一个指针，返回指针的时候需要我们注意些什么？

通常情况下，我们是希望为函数外提供一片内存，例如，我们可以给函数外面提供一个数组。

int * func()
{
   int arr[] = {1, 2, 3, 4};
   return arr;
}

但是这样写得话，程序会崩溃掉。原因是，arr 数组是一个局部变量，在 func 结束之后，其内存就被销毁掉了。此时在函数外面对其进行操作，自然会出问题。所以，要完成这类操作，我们需要把内存分配到堆内存上面。

int * func()
{
   int * arr = (int *)malloc(4 * sizeof(int));
   return arr;
}

这样就没有问题了，当然，既然是分配在了堆内存上，就要记得手动销毁。

int main(int argc,char **argv)
{
   int * p = func();
   free(p);
   return 0;
}

代码块中定义的变量被称之为局部变量。它们在其他函数的语句中是不可见的，也无法访问它们。

全局变量是在所有函数体的外部定义的，程序的所有部分都可以使用。全局变量不受作用域的影响，其生命周期一直到程序的结束。

int a = 2;

int main(int argc,char **argv)
{
   return 0;
}

静态变量受作用域的影响，其生命周期一直到程序的结束。

例如：

void func()
{
   static int a = 0;
}

我们可以在函数中申明一个静态变量。值得注意的是，这个变量的作用域虽然是在函数内，但是他并不会随着函数结束而被销毁，它会一直存在到程序的结束。

指针可以指向一个数组，例如：

#include <stdio.h>

int main(int argc,char **argv)
{
   int arr[] = {1, 2, 3, 4};
   int * p = arr;
   return 0;
}

比较特殊的是，数组名就是一个指针，不过数组名是一个常量指针，不能做累加或者累减操作。

我们可以通过指针来访问数组元素：

*(p + 2)

同样，这句话等价于：

p[2]

指针可以指向一个变量，例如：

#include <stdio.h>

int main(int argc,char **argv)
{
   int a = 0;
   int * p = &a;
   return 0;
}

如果想要通过指针操作变量，只需要使用解引用就可以了：

*p = 20;