类和对象
认识类和对象
先来回忆一下C语言中的类型和变量，类型就像是定义了数据的规则，而变量则是根据这些规则来实际存储数据的容器。类是我们自己定义的一种数据类型，而对象则是这种数据类型的一个具体实例。类就可以理解为类型，而对象就可以理解为变量，而且对象是更加高级的变量。
类型 = 类型数据 + 类型操作
比如double类型
他的数据类型占用8字节，并且可以表示成小数。
类型操作可以加减乘除，但是它不支持模(%)运算。
那么类就是包含了类型数据和类型操作的一个集合。
也可以理解为数据就是类的属性，操作就是类的行为
通过下面我定义的一个人的类，那么height,sex, age都是这个类的类型数据，而类型操作就是函数run和函数speak。
class People {
double height;//身高
char sex;//性别
int age;//年龄
string name;//姓名
void run() {//跑
cout << "I can run" << endl;
}
void speak() {//说话
cout << "I can speak" << endl;
}
};那么我需要一个特定的人的时候，我就需要定义一个对象用来存这个特定人的属性。
下面的用类定义一个对象，并且对他的属性进行赋值。
People a;
a.name = "Zhang san";
a.age = 18;
a.sex = '1';//女0，男1
a.height = 1.89;而我需要这个人进行说话或者跑时，就需要调用他相应的操作，也就是函数。
a.run();
a.speak();访问权限
public：是公共的资源，是谁都可以访问的资源，比如空气，阳光，公共场合都是谁都可以访问进行使用的。
private：是私有的资源，是只能类自己进行访问的资源，比如每个人自己的私人物品，是只能自己使用和访问的。
protected：是受保护的资源，是只能自己访问以及自己的子类访问的资源，比如你儿子可以使用你的东西。(在后续文章继承时会用到protected权限)
friendly：是在关键字friend声明后，它允许被声明后的类或函数访问这一个类的私有或受保护的资源，比如你的好兄弟在你的允许下可以访问和使用你的私人物品。(在后续的文章中会更新到使用)
重点：这里的访问权限是规定的类外对该类类内的访问权限。
比如我在一个类中定义了一个访问权限为私有的方法，那么我只能在这个类的内部进行调用，在类外是无法调用的，除非我对这个方向进行了friend友元声明。
对于为什么要为什么要有访问权限的设置，看如下代码：
#include<iostream>
using namespace std;
class People {
public :
int age;
void speak() {
cout << "my age is "<< age << endl;
return ;
}
};
int main() {
People a;
a.age = -100;
a.speak();
return 0;
}如果对于age是public公有访问的，那么在设置年龄的将不会受到限制，对于这份代码可能没有问题，如果在以后设计项目或者工程时，就会造成灾难性的错误。
那么正确的写法应该如下，把age设置为私有的，对age赋值时，定义一个函数来进行对age赋值，并判断值是否在正确范围内，对于获取age值也定义一个函数进行来获取。
#include<iostream>
using namespace std;
class People {
public :
void speak() {
cout << "my age is "<< age << endl;
return ;
}
void set_age(int x) {
if (age <= 0 || age > 1000) {
perror("your age is error\n");
exit(1);
}
age = x;
return ;
}
int get_age() {
return age;
}
private :
int age;
};
int main() {
People a;
a.set_age(-100);
a.speak();
return 0;
}构造函数和析构函数
定义一个对象的流程：
对于构造函数的详细解析如下代码：
#include<iostream>
using namespace std;
class A {
public :
A() {//默认构造函数
cout << "default constructor" << endl;
}
//如果这里没有const关键字,传入的对象是const声明的那么就会报错
//如果没有&(引用),那么将会造成无限套娃的拷贝构造
//假如这里没有&，那么这里的形参就相当于实参给他赋值
//而赋值就是 A a = b, b是实参传入的值
//那这里就会又调用构造函数,形成无限套娃
A(const A &a) {
this->x = a.x;
this->y = a.y;
cout << "copy constructor" << endl;
}
A(int x, int y) {//有参构造函数
cout << "have parameter constructor" << endl;
this->x = x;//this表示当前对象的地址
this->y = y;
}
void operator=(const A &a) {//这个函数是=运算符重载，是类中默认有的
cout << "this is assigment" << endl;
return ;
}
A(int x) {//转换构造函数
cout << "conversion constructor" << endl;
this->x = x;
this->y = 0;
}
void output() {
cout << "(" << x << ", " << y << ")" << endl;
}
~A() {//析构函数
cout << "destructor" << endl;
}
private :
int x, y;
};
void func(A a) {
cout << "func : ";
a.output();
return ;
}
int main() {
A a;//调用默认构造函数
cout << "1-------------------------" << endl;
A b(1, 2);//调用有参构造
cout << "2-------------------------" << endl;
//这里就调用了拷贝构造函数
A e = b;
cout << "3-------------------------" << endl;
//这里只是运用了普通赋值运算符
//通过执行会发现没有执行任何构造函数
a = b;
cout << "4-------------------------" << endl;
//调用转换构造，将int类型转换为A类型
//这里也可以是另一个类型的对象，那也是转换构造
//不过还需要从新定义一个需要转换构造的函数,里面的参数就是对应的类型
A c(3);
cout << "5-------------------------" << endl;
//这里调用的是拷贝构造函数，将对象b进行拷贝给函数形参a
func(b);
func(c);
cout << "6-------------------------" << endl;
//对于这中函数调用情况
//这里就会用到转换构造
//他会隐式的将int类型5通过转换构造转会为A类型
func(5);
cout << "7-------------------------" << endl;
//这里相当于A d(4);
//这里可以这样理解
//等号类型相同编程才能通过
//那么4，int类型就会通过转换构造变成A类型
//如果没有转换构造那么就编译无法通过
A d = 4;
a = 6;
cout << "8-------------------------" << endl;
return 0;
}构造函数的初始化列表
构造函数中的初始列表使用：
#include<iostream>
using namespace std;
class C {
public:
C(int n) {
this->num = n;
cout << "C coversion constructor" << endl;
}
void output() {
cout << num;
}
private :
int num;
};
class A {
public :
//:后面是构造函数的初始化列表
A(int a) : a(a), b(10), c(6) {
cout << "A constructor" << endl;
}
void output() {
cout << " " <<a << " " << b << " ";
c.output();
cout << endl;
return ;
}
private :
int a, b;
C c;
};
int main() {
A a(2);
a.output();
return 0;
}构造函数和析构函数的调用顺序
如下这份代码：
#include <iostream>
#include <string>
using namespace std;
class A {
public :
A() {};
A(string n) {
name = n;
cout << name << " class A construtor" << endl;
}
~A() {
cout << name << " class A destructor" << endl;
}
int *p;
private :
string name;
};
class B {
public :
//:a(a)
//:后面是构造函数时，最该对象中的成员属性进行初始化操作
B(string n, A &a) : a(a){
name = n;
cout << name << " class B construtor" << endl;
//new关键字可以理解为，C语言中malloc去堆区中开辟一段空间
a.p = new int[10];
return ;
}
A &a;//创建一个引用属性，这里&a可以暂时理解为取a的地址
~B() {
//delete就相当于C语言中的free对开辟空间的释放
delete a.p;
cout << name << " class B destructor" << endl;
}
private :
string name;
};
int main() {
A a("a");
B b("b", a);
return 0;
}执行结果：
可以发现，析构顺序是构造顺序反过来的，通过代码可以发现在B中的有参构造中用到了a对象的引用，然后对a对象的p指针开辟了一段空间，如果析构时顺序和构造顺序一样的那么，在析构b对象时，去delete a.p去释放开辟的空间时，a对象已经被析构掉了，那就也无法去找a对象中的指针p了。
类属性与方法
对于上面的代码的类中，它们只有成员属性和成员方法。
就拿文章中的第一份代码来看，对于属性，也就是类中的变量，他所存储的值是跟着对象改变而改变的，而类中的两个方法(函数)，也是随着对象改变而改变的，因为它们的输出也是不同的。所以这些叫做成员属性和成员方法。
class People {
double height;//身高
char sex;//性别
int age;//年龄
string name;//姓名
void run() {//跑
cout << name << " can run" << endl;
}
void speak() {//说话
cout << name << " can speak" << endl;
}
};下面这份代码是对成员属性和成员方法的使用：
#include<iostream>
using namespace std;
class Point {
public :
Point() : x(0), y(0) {} //默认构造
//区分x和y
//在x(x),括号外是成员属性x,括号内是形参x
Point(int x, int y) : x(x), y(y) {} //有参构造
void set_x (int x) { this->x = x; }
void set_y (int y) { this->y = y; }
int get_x() {
//访问类中的类属性
Point::get_x_cnt += 1;
return this->x;
}
int get_y() { return this->y; }
//这里是直接定义了类方法
static int x_cnt() {
return Point::get_x_cnt;
}
private :
//这里只是声明了这个变量
//get_x_cnt,记录变量x在被get时,在整个程序执行时被调用了多少次
static int get_x_cnt;
int x, y;
};
//这里就是定义了get_x_cnt, 并且给他的值进行了初始化
int Point::get_x_cnt = 0;
int main() {
Point p1(3, 4), p2(5, 6);
cout << p1.get_x() << ", " << p1.get_y() << endl;
cout << p2.get_x() << ", " << p2.get_y() << endl;
p1.get_x();
p1.get_x();
p1.get_x();
cout << "x_cnt : " << Point::x_cnt() << endl;
return 0;
}const 方法
对于const和mutable关键字使用，对于上一份代码的修改：
#include<iostream>
using namespace std;
class Point {
public :
Point() : x(0), y(0) , get_x_cnt(0){} //默认构造
Point(int x, int y) : x(x), y(y), get_x_cnt(0) {} //有参构造
void set_x (int x) { this->x = x; }
void set_y (int y) { this->y = y; }
int get_x() const { //修改处
get_x_cnt += 1;
return this->x;
}
int get_y() const { return this->y; }//修改处
int x_cnt() const {//修改处
return get_x_cnt;
}
private :
//现在get_x_cnt，表示当前对象对get_x函数的调用次数
//mutable关键字表示不收const关键之的限制
//所以就算有const关键字，那么mutable声明的变量也可以进行修改
mutable int get_x_cnt;
int x, y;
};
int main() {
const Point p(10, 15), p2(1, 2);
cout << p.get_x() << ", " << p.get_y() << endl;
p2.get_x();
p2.get_x();
cout << "p1 : get_x_cnt = " << p.x_cnt() << endl;
cout << "p2 : get_x_cnt = " << p2.x_cnt() << endl;
return 0;
}类的声明和定义
还是对类属性和类方法的那份代码进行修改：
#include<iostream>
using namespace std;
//在类中只放方法的声明
class Point {
public :
Point();
Point(int x, int y);
void set_x (int x);
void set_y (int y);
int get_x() const;
int get_y() const;
static int x_cnt();
private :
static int get_x_cnt;
int x, y;
};
//对于类中的方法进行实现
//那么就可以将这两部分拆开
//定义放在源文件中，声明放在头文件中
Point::Point() : x(0), y(0) {}
Point::Point(int x, int y) : x(x), y(y) {}
void Point::set_x(int x) {
this->x = x;
}
void Point::set_y(int y) {
this->y = y;
}
int Point::get_x() const{
Point::get_x_cnt += 1;
return x;
}
int Point::get_y() const{
return y;
}
int Point::x_cnt() {
return Point::get_x_cnt;
}
int Point::get_x_cnt = 0;
int main() {
Point p1(3, 4), p2(5, 6);
cout << p1.get_x() << ", " << p1.get_y() << endl;
cout << p2.get_x() << ", " << p2.get_y() << endl;
p1.get_x();
p1.get_x();
p1.get_x();
cout << "x_cnt : " << Point::x_cnt() << endl;
return 0;
}default和delete关键字
delete和default关键字引用代码：
#include<iostream>
using namespace std;
class A {
public :
//A() = delete;
A() {
cout << "default constructor" << endl;
}
A(int n) : x(n) {
cout << "conversion constructor" << endl;
}
A(const A &) {
cout << "copy constructor" << endl;
}
private :
int x;
};
class B {
public :
B() = default;
B(const B&) = default;
private :
A a1, a2, a3;
};
class C {
public :
C() = default;
//C(const C&) {}//这种情况叫撒比构造
C(const C&) = default;
private :
A a1, a2, a3;
};
class Point {
public :
Point() = default;//请求编译器生成默认构造函数
Point(int x, int y) : x(x), y(y) , p(new int(5)), a(1){}
//Point(const Point &) = delete;//删除编译器的拷贝构造函数
//Point(const Point &) = default;//拷贝函数生成默认行为,在使用这个拷贝构造函数时就会造成双重释放的报错
//这就是深拷贝
Point(const Point &a) : x(a.x + 1), y(a.y + 2), a(a.a){
//如果这里成员属性a直接用这样去赋值拷贝
//那么成员属性a就会使用A类的默认构造函数进行构造
//而A类的默认构造函数已经被删除了，那么就会报错
//this->a = a.a;
this->p = new int;
*(this->p) = *(a.p);
}
~Point() {
delete p;
}
private :
A a;
int *p;
int x, y;
};
int main() {
Point p1(1, 2), p2 = p1;
return 0;
}
