《面向对象概述》
1.面向过程的结构化编程：
把数据和动作分开放置，把数据放入到动作当中。采用自顶向下的方法构建程序，包含顺序，选择和循环三种结构。
按照程序执行的时序步骤来完成。
2.面向对象编程：
把对象当成程序的基本单元。一个对象包含数据和操作数据的函数，即成员变量和成员函数。这个抽象化的事物我们称之为类。
这个类就像模板或者图纸，可以通过这个类生产出一个个实例，这个过程就称为实例化。而产生出的具体的东西都叫做对象。
一个类可以实例化无数个对象。每个对象都包含类中定义的成员变量和成员函数。
3.类：
类，是 C++ 实现面向对象最基础的部分。类其实和之前学过的结构体十分相似，你可以认为类是结构体的升级版。
class Staff
{
}; 在C++中，声明一个类必须加分号";"
4.new delete
要将生产出的对象分配到堆上，需要使用new 和 delete。new 用来分配对象，delete 用来删除对象。
new 会返回一个指针，在使用完毕后，要通过 delete 把这个指针指向的地址释放掉。
int main(int argc,char **argv)
{
Staff st1; //栈上实例化
Staff * st2 = new Staff(); // 堆上实例化
delete st2; // 记得释放
return 0;
}
5.成员变量
#include <string> //在h,pp中定义
class Staff //在类中定义成员变量
{
std::string name; //std::string 是 C++ 中用来存放字符串的类型
int age; // int 是整数类型
};
#include <stdio.h>
#include "Staff.hpp" // 在使用类的时候，首先先要引用到这个类的头文件
int main(int argc,char **argv)
{
Staff staff1; // 实例化之后，staff1 和 staff2这两个变量中，都各自包含 std::string name 和 int age 的两个变量。
Staff staff2;
return 0;
}
6.权限修饰符 public private protected
a. public //用来指定公有成员。一个类的公有成员在任何地方都可以被访问。
class A{
public: //用 public 修饰的，在外部是可以访问的。
int a;
int b;
}
int main(int argc,char **argv){
A a;
a.a = 15; // 不会报错，因为成员变量是 public 的
return 0;
}
b. private // 用来指定私有成员。一个类的私有成员，不论是成员变量还是成员函数，都只能在该类的内部才能被访问
class A{
private: //私有成员是不能在外部使用的
int a;
int b;
}
int main(int argc,char **argv){
A a;
a.a = 15; // 会报错，因为成员变量是 private 的
return 0;
}
c. protected //用来指定保护成员。一般是允许在子类中访问。
7.成员函数
我们可以在头文件中用以下的代码定义一个成员函数。
#include <string>
class Staff{
public:
std::string name;
int age;
int PrintStaff();
};
在头文件中，定义一个成员函数，这个成员函数的功能是打印雇员的信息。而这个函数的实现，是在 .cpp 文件里面实现的。
打开 .cpp 文件，先 include 头文件，然后用以下的代码对函数进行实现。
#include "Staff.hpp"
int Staff::PrintStaff(){
printf("Name: %s\n", name.c_str());
printf("Age: %d\n", age);
return 0;
}
之后，回来 main 函数，就可以使用这个成员函数了。
#include <stdio.h>
#include "Staff.hpp"
int main(int argc,char **argv){
Staff staff1;
staff1.PrintStaff();
Staff staff2;
staff2.PrintStaff();
return 0;
}
成员函数同样受到权限修饰符的限制。
函数写到了 public 下面，我们可以在类的外部对其进行调用，
而 private 修饰的函数只能在类中被其他成员函数调用。
8.成员函数的重载
成员函数的重载是指在同一个类中，函数名字相同，函数参数不同的函数。
#include <string>
class Staff{
public:
void FuncA();
void FuncA(int a);
};
这个类中，我们定义了两个函数，都叫做 FuncA，但是他们的参数不一样，一个没有参数，一个参数是一个 int 类型的变量。
这种情况下，两个函数都是有效的。而在调用的时候，C++ 会根据调用者传入的函数自行匹配相应的实现。
9.构造函数和析构函数 //是特殊的成员函数。
a. 构造函数
#include <string>
class Staff{
public:
Staff();
};
可以看到，这里定义了一个和名称和类名相同，没有返回值的函数，这个函数称为构造函数。构造函数的特殊之处在于，
他会在类实例化的时候被调用。
我们先实现一下这个函数，在函数中打印一行：
#include "Staff.hpp"
#include <stdio.h>
Staff::Staff(){
printf("构造函数被调用\n");
}
然后在 main 中调用一下：
#include <stdio.h>
#include "Staff.hpp"
int main(int argc,char **argv){
Staff staff1;
return 0;
}
运行的时候，可以看到，刚刚的那条打印语句被运行了。
此外，构造函数是可以有参数的，我们常常用构造函数来进行初始化。
例如，我们可以利用构造函数对 name 和 age 进行传值。
#include <string>
class Staff{
public:
Staff(std::string _name, int _age);
public:
std::string name;
int age;
};
#include "Staff.hpp"
#include <stdio.h>
Staff::Staff(std::string _name, int _age){
name = _name;
age = _age;
}
#include <stdio.h>
#include "Staff.hpp"
int main(int argc,char **argv){
Staff staff("mooc", 29); //对于有参数的构造函数，调用的时候只要传进去参数就行了
return 0;
}
b. 析构函数
对象实例化的时候，会调用构造函数，而对象销毁的时候，就会调用析构函数
#include <string>
class Staff{
public:
Staff(std::string _name, int _age);
~Staff();
public:
std::string name;
int age;
};
#include "Staff.hpp"
#include <stdio.h>
Staff::Staff(std::string _name, int _age){
name = _name;
age = _age;
printf("构造函数被调用\n");
}
Staff::~Staff()
{
printf("析构函数被调用\n");
}
#include <stdio.h>
#include "Staff.hpp"
int main(int argc,char **argv){
Staff staff1;
return 0;
}
我们发现，程序在调用了构造函数之后，又调用了析构函数。
我们之前讲过栈内存，这个对象是分配在栈上面的，实例化的时候，调用了构造函数，而紧接着，main 函数就要结束了，
这个栈对象就自动销毁了，销毁的时候，就调用了析构函数。
10.赋值构造函数 //是特殊的构造函数
即构造函数A赋值给构造函数B。当构造函数A含有指针变量时，C++ 默认的复制模式只会简单得把指针的值进行拷贝。
最后的结果就是A、B指针指向了同一片内存。这种拷贝方式，被称之为浅拷贝。
当我们使用这种方式实例化对象的时候，并不会调用普通构造函数，而是会调用一个特殊的构造函数，被称之为赋值构造函数
或者拷贝构造函数。如果我们没有写，那么就会按照浅拷贝的方式来进行复制。
Staff(const Staff & taff); //是特殊的构造函数的写法。在.hpp和中.cpp各加入一个这种函数。
11.运算符重载
在 C++ 中，有很多符号都可以重载，也有一些不能被重载。
可重载的运算符：
不可重载的运算符：
.
.* ->*
::
sizeof
?:
#
搜索
复制
标签：include,函数,int,C++,name,面向对象,概述,Staff,构造函数 From： https://www.cnblogs.com/XingHaiJiaYuan/p/16623905.html