C++面向对象

万里顾一程
34 阅读6分钟

1、封装

封装

将属性和行为作为一个整体，表现生活中的事务

将属性和行为加以权限控制

成员变量和成员函数

class Student{
public:
    //成员变量
    char *name;
    int age;
    float score;
    //成员函数
    void say(){
        cout<<name<<"的年龄是"<<age<<"，成绩是"<<score<<endl;
    }
};

成员变量和普通变量一样，也有数据类型和名称，占用固定长度的内存。但是，在定义类的时候不能对成员变量赋值，因为类只是一种数据类型或者说是一种模板，本身不占用内存空间，而变量的值则需要内存来存储。

成员函数是一个类的成员，出现在类体中，它的作用范围由类来决定；而普通函数是独立的，作用范围是全局的，或位于某个命名空间内。

权限

类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。

C++ 中的 public、private、protected 只能修饰类的成员，不能修饰类，C++中的类没有共有私有之分。

在类的外部（定义类的代码之外），只能通过对象访问成员，并且通过对象只能访问 public 属性的成员，不能访问 private、protected 属性的成员。

struct 和 class 的区别

区别：

  • 使用 class 时，类中的成员默认都是 private 属性的；而使用 struct 时，结构体中的成员默认都是 public 属性的

  • class 继承默认是 private 继承，而 struct 继承默认是 public 继承

  • class 可以使用模板，而 struct 不能

属性私有

优点：

  1. 将所有成员属性设置为私有，可以自己控制读写权限
  2. 对于写权限，我们可以检测数据的有效性

2、对象初始化和清理

构造函数

主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用

class Person {
public:
	int m_age;
	Person() {
		cout << "Person的无参构造" << endl;
	}
	Person(string name,int age) {
		 m_age = age;
		cout << "Person的有参构造" << endl;
	}
    	Person(const Person &p) {
		 m_age = p.m_age;
		cout << "Person的拷贝构造" << endl;
	}

};

析构函数

主要作用在于对象销毁前由系统自动调用，执行一些清理工作，

程序在对象销毁前会自动调用析构，无需手动调用，而且只会调用一次

class Person {
public:
	int m_age;
	~Person() {
		cout << "Person的析构函数" << endl;
	}
};

深拷贝和浅拷贝

浅拷贝：简单的赋值拷贝

深拷贝：在堆区重新申请空间，进行拷贝工作

浅拷贝带来的问题：堆区的内存重复释放

深拷贝解决：自己提供拷贝构造函数，给拷贝的副本重新开辟内存空间

Person(const Person &p) {
		m_age = p.m_age;
		m_Height = new int(*p.m_Height);
	}

如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

构造和析构函数的调用

#include<iostream>
using namespace std;

//分类
class Person {
public:
	int m_age;
	Person() {
		cout << "Person的无参构造" << endl;
	}
	Person(int age) {
		m_age = age;
		cout << "Person的有参构造" << endl;
	}
	Person(const Person& p) {
		m_age = p.m_age;
		cout << "Person的拷贝构造" << endl;
	}
	~Person() {
		cout << "Person的析构函数" << endl;
	}
};
//调用
void test01() {
	//1.括号法
	Person p1;
	Person p2(30);
	Person p3(p2);//调用拷贝构造

	cout << "p2的年龄" << p2.m_age << endl;
	cout << "p3的年龄" << p3.m_age << endl;

	//2.显示法
	Person p4;
	Person p5 = Person(10);
	Person p6 = Person(p5);

	cout << "p5的年龄" << p5.m_age << endl;
	cout << "p6的年龄" << p6.m_age << endl;
	Person(10);//匿名对象 当前行执行结束，系统会立即回收匿名对象，不要用拷贝函数初始化匿名对象


	//3.隐式转换法
	//等价于 Person p7 = Person(p6)
	Person p7 = p6;
	//等价于 Person p8 = Person(10)
	Person p8 = 10;
}

int main() {
	test01();
	system("pause");
	return 0;
}

拷贝函数使用场景

1、使用一个已创建的对象来初始化一个新的对象

Person p1;
Person p3(p1);

2、值传递的方式来给函数参数传值

//形参是实参拷贝的副本
void doWork(Person p) {
	
}
void test02() {

	Person p1;
    //值传递的方式来给函数参数传值
	doWork(p1);
}

3、以值方式返回局部对象

//返回的对象是局部对象拷贝的副本
Person doWork2() {
	Person p2;
	return p2;
}

void test03() {
	Person p3 = doWork2();
}

构造函数调用规则

默认情况下c++构造器至少给一个类添加3个函数

  • 默认构造函数（无参，函数体为空）

  • 默认析构函数（无参，函数体为空）

  • 默认拷贝构造函数，对属性进行值拷贝

构造函数的调用规则如下：

  • 如果用户定义有参构造，c++不再提供默认无参构造，但还是会提供默认拷贝构造函数
  • 如果用户提供拷贝构造函数，c++不会再提供其他构造函数

初始化列表

初始化列表：用来初始化属性

#include<iostream>
using namespace std;

class Person {
public:
	int age;
	int height;
	int weight;

	//传统初始化属性
	/*P(int a, int b, int c){
	   m_A = a;
	   m_B = b;
	   m_C = c;
	}*/
    
	//初始化列表
	Person(int a, int b, int c) :age(a), height(b), weight(c) 
    {
	}
};

void test01() {
	Person p(18, 180, 130);
	cout << p.age << endl;
	cout << p.height << endl;
	cout << p.weight << endl;
}

int main() {
	test01();
	system("pause");
	return 0;
}

类对象作为类成员

C++类中的成员允许是另一个类的对象，我们称该成员为：对象成员

当其他类的对象作为本类的成员：

  • 在构造中，是先构造其他类的，在构造本类的。
  • 在析构中，是先析构本类，再析构他类。

静态成员

静态成员变量：

  1. 所有对象共享同一份数据
  2. 在编译阶段分配内存
  3. 类内声明，类外初始化

静态成员函数：

  1. 所有对象共享同一个函数
  2. 静态成员函数只能访问静态成员函数
  3. 静态成员函数可以访问静态成员变量，不能访问非静态成员变量

静态成员访问方式：

  1. 通过对象进行访问
  2. 通过类名进行访问

3、c++对象模型和this指针

成员变量和成员函数分开存储

在c++中类内的成员变量和成员函数是分开存储的，只有非静态成员变量才属于类的对象

#include<iostream>
using namespace std;

//空对象
class Person {

};
class Demo {
	int m_A;//非静态成员变量属于对象上
};
class Student {
	//非静态成员函数不在对象上
	void sayHello() {

	}
};

class Work {
	//静态变量不在对象上
	static int a;
	static void sayHello() {
		cout << "你好呀" << endl;
	}
};
//类外初始化静态变量
int Work::a = 10;
void test01() {
	Person p;
	//在c++中，为了区别不同的空对象，编译器为其赋了一个字节的存储空间
	cout << sizeof(p) << endl;//1  空对象

	Demo d;
	cout << sizeof(d) << endl;//4   非静态成员变量属于对象上

	Student s;//空对象
	cout << sizeof(s) << endl;//1   非静态成员函数不在对象上

	Work w;//空对象
	cout << sizeof(w) << endl;//1  静态变量不在对象上
}
int main() {
	test01();
	system("pause");
	return 0;
}

this指针

this 是 C++中的一个关键字，也是一个 const 指针，它指向当前对象，通过它可以访问当前对象的所有成员。

#include<iostream>
using namespace std;

class Person {
public:
	int age;
	Person(int age) {
		//this指向成员变量或成员函数被调用的对象
		this->age = age;
	}
	//如果返回的是一个引用，则返回的是本身
	Person& personAddAge(Person& person) {
		this->age += person.age;
		//this指向p2的指针，而*this指向p2这个对象本体
		return *this;
	}
	//如果返回的是一个对象，则相当于创建了一个新的对象
	Person personAddAge1(Person& person) {
		this->age += person.age;
		return *this;
	}
};

void test01() {
	Person p(18);
	cout << "p的年龄为" << p.age << endl;
}

void test02() {
	Person p1(10);
	Person p2(10);
	Person p3(10);
	p2.personAddAge(p1).personAddAge(p1).personAddAge(p1);
	p3.personAddAge1(p1).personAddAge1(p1).personAddAge1(p1);
	cout << "p2的年龄为：" << p2.age << endl;//40
	cout << "p3的年龄为：" << p3.age << endl;//20
}
int main() {

	test01();//18
	test02();
	system("pause");
	return 0;
}

注意事项：

  • this 是 const 指针，它的值是不能被修改的，一切企图修改该指针的操作，如赋值、递增、递减等都是不允许的。
  • this 只能在成员函数内部使用，用在其他地方没有意义，也是非法的。
  • 只有当对象被创建后 this 才有意义，因此不能在静态成员函数中使用。

空指针访问成员函数

c++中空指针也是可以调用this指针的，但是也要注意有没有用到this指针

如果用到this指针，需要加以空指针判断保证代码的健壮性

#include<iostream>
using namespace std;

class Person {
public:
	int m_Age;
	void showClass() {
		cout << "这是小学一年级" << endl;
	}
	void showAge() {
		//对this做判空处理，增强代码的健壮性，防止空指针带来的异常
		if (this == NULL) {
			cout << "空指针"<< endl;
			return;
		}
		cout << "你的年龄" << this->m_Age << endl;
	}
};
void test01() {
	//创建一个空指针
	Person* p = NULL;
	p->showClass();//空指针可以调用成员函数
	p->showAge();//由于空指针直接调用导致程序崩溃 解决方案，在成员函数中，对this多加一层判断
}
int main() {
	test01();
	system("pause");
	return 0;
}

const修饰成员函数

常函数：

  1. 成员函数后加上const后我们称这个函数为常函数
  2. 常函数内不可以修改成员属性
  3. 只有在成员属性声明时加上关键字mutable，才可以在常函数内进行修改

常对象：

  1. 声明对象前加const，称声明对象为常对象
  2. 常对象只能调用常函数
#include<iostream>
using namespace std;
class P {
public:
	int m_A;
	mutable int m_B; // mutable 修饰的成员属性

	//常函数
	void changeValue() const {
		//this->m_A = 200;  常函数内不可以修改成员属性
		m_B = 20;// mutable 修饰的成员属性可以在常函数进行修改
	}

	void func() {
	}
};

void test01() {
	P p;
	p.changeValue();
}
void test02() {
	//在对象前加上关键字const修饰，变为常对象
	const P p;
	//p.m_A = 20;
	p.m_B = 30;//被mutable修饰的成员属性，在常对象下也可以进行修改
	//p.func(); //常对象不可以调用普通的成员函数，因为普通的成员函数可以修改成员属性
	p.changeValue();//常对象只能调用常函数
}
int main() {

	test01();
	test02();
	system("pause");
	return 0;
}
avatar
文章
阅读
粉丝