C++类与对象

最新推荐文章于 2024-08-09 01:30:32 发布

jsaper_ye

最新推荐文章于 2024-08-09 01:30:32 发布

阅读量745

点赞数 2

文章标签： c++ 开发语言后端

本文链接：https://blog.csdn.net/Bigpity/article/details/122649993

版权

第一次写博客，有缺点希望大家指出

面向对象程序设计是一种新的程序设计范型。

面向过程程序设计范型是使用较广泛的面向过程性语言，其主要特征是：程序由过程定义和过程调用组成（简单地说，过程就是程序执行某项操作的一段代码，函数就是最常用的过程）。

面向对象程序的基本元素是对象，面向对象程序的主要结构特点是：第一，程序一般由类的定义和类的使用两部分组成；第二，程序中的一切操作都是通过向对象发送消息来实现的，对象接收到消息后，启动有关方法完成相应的操作。

class（类）：类是具有相同的数据和相同的操作的一组对象的集合。

首先，c++的基本知识先介绍一下：

作用域标识符"::"
通常情况下，如果有两个同名变量，一个是全局的，另一个是局部的，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局变量。

如果希望在局部变量的作用域内使用同名的全局变量，可以在该变量前加上“::”，此时::value代表全局变量value，“::”称为作用域标识符。

#include <iostream>
using namespace std;

int num;//全局变量

int main() {
	int num;//局部变量
		num = 100;
	::num = 1000;
	cout << "local num is :" << num << endl;
	cout << "global num is :" << ::num << endl;//::调出全局变量
	return 0;
}

函数重载:

在C++中，用户可以重载函数。这意味着，在同一作用域内，只要函数参数的类型不同，或者参数的个数不同，或者二者兼而有之，两个或者两个以上的函数可以使用相同的函数名。

#include <iostream>
using namespace std;

int add(int x, int y)
{
	return x + y;
}

double add(double x, double y)
{
	return x + y;
}

int add(int x, int y, int z)
{
	return x + y + z;
}

int main() 
{
	int a = 3, b = 5, c = 7;
	double x = 10.334, y = 8.9003;
	cout << add(a, b) << endl;
	cout << add(x, y) << endl;
	cout << add(a, b, c) << endl;
	return 0;
}

在调用函数时，如果给出的实参和形参类型不相符，C++的编译器会自动地做类型转换工作

new和delete运算符:
程序运行时，计算机的内存被分为4个区：程序代码区、全局数据区、堆和栈。其中，堆可由用户分配和释放。C语言中使用函数malloc()和free()来进行动态内存管理。C++则提供了运算符new和delete来做同样的工作，而且后者比前者性能更优越，使用更灵活方便。

指针变量名 = new 类型
    int *p;
    p = new int;
delete 指针变量名
    delete p;

用运算符new分配的空间，使用结束后应该用也只能用delete显式地释放，否则这部分空间将不能回收而变成死空间。
在使用运算符new动态分配内存时，如果没有足够的内存满足分配要求，new将返回空指针

指针变量名 = new 类型名(初值);
int *p;
p = new int(99);
···
delete p;

class（类）：

其实我觉得class与C语言struct（结构）相似，只是多了一个成员函数（刚学不太懂）

类声明中的内容包括数据和函数，分别称为数据成员和成员函数。按访问权限划分，数据成员和成员函数又可分为共有、保护和私有3种。

class 类名{
public：
公有数据成员；
公有成员函数；
protected:
保护数据成员；
保护成员函数；
private:
私有数据成员；
私有成员函数；
};
小规则：

1：对一个具体的类来讲，类声明格式中的3个部分并非一定要全有，但至少要有其中的一个部分。

2：类声明中的关键字private、protected、public可以任意顺序出现。

3 ：如果一个类体中没有一个访问权限关键字，则其中的数据成员和成员函数都默认为私有的。

4 ：不能在类声明中给数据成员赋初值

普通成员函数：

在类的声明中只给出成员函数的原型，而成员函数的定义写在类的外部。这种成员函数在类外定义的一般形式是：

/*返回值类型 类名::成员函数名(参数表){    函数体}*/

class Score{
public:
	void setScore(int m, int f);
	void showScore();
private:
	int mid_exam;
	int fin_exam;
};

void Score::setScore(int m, int f) 
{
	mid_exam = m;
	fin_exam = f;
}

void Score::showScore()
{
	cout << "期中成绩: " << mid_exam << endl;
	cout << "期末成绩：" << fin_exam << endl;
}

内联成员函数的定义:

隐式声明：将成员函数直接定义在类的内部

class Score{
public:
	void setScore(int m, int f)
	{
		mid_exam = m;
		fin_exam = f;
	}
	void showScore()
	{
		cout << "期中成绩: " << mid_exam << endl;
		cout << "期末成绩：" << fin_exam << endl;
	}
private:
	int mid_exam;
	int fin_exam;
};

对象的定义:

在声明类的同时，直接定义对象

class Score{
public:
	void setScore(int m, int f);
	void showScore();
private:
	int mid_exam;
	int fin_exam;
}op1, op2;

类的作用域和类成员的访问属性（重点）：

私有成员只能被类中的成员函数访问，不能在类的外部，通过类的对象进行访问。

公有成员是类的对外接口，而私有成员是类的内部数据和内部实现，不希望外界访问。将类的成员划分为不同的访问级别有两个好处：一是信息隐蔽，即实现封装，将类的内部数据与内部实现和外部接口分开，这样使该类的外部程序不需要了解类的详细实现；二是数据保护，即将类的重要信息保护起来，以免其他程序进行不恰当的修改。

对象赋值语句（比较特殊）

	Score op1, op2;
	op1.setScore(99, 100);
	op2 = op1;
	op2.showScore();

构造函数与析构函数

构造函数

构造函数是一种特殊的成员函数，它主要用于为对象分配空间，进行初始化。构造函数的名字必须与类名相同，而不能由用户任意命名。它可以有任意类型的参数，但不能具有返回值。它不需要用户来调用，而是在建立对象时自动执行。

class Score{
public:
	Score(int m, int f);  //构造函数
	void setScore(int m, int f);
	void showScore();
private:
	int mid_exam;
	int fin_exam;
};

Score::Score(int m, int f)
{
	mid_exam = m;
	fin_exam = f;
}

在建立对象的同时，采用构造函数给数据成员赋值，通常由以下两种形式

类名 对象名[(实参表)]
Score op1(99, 100);
op1.showScore();

类名 *指针变量名 = new 类名[(实参表)]
Score *p;
p = new Score(99, 100);
p->showScore();
-----------------------
Score *p = new Score(99, 100);
p->showScore();

说明：

构造函数的名字必须与类名相同，否则编译程序将把它当做一般的成员函数来处理。
构造函数没有返回值，在定义构造函数时，是不能说明它的类型的。
与普通的成员函数一样，构造函数的函数体可以写在类体内，也可写在类体外。
构造函数一般声明为共有成员，但它不需要也不能像其他成员函数那样被显式地调用，它是在定义对象的同时被自动调用，而且只执行一次。
构造函数可以不带参数。

成员初始化列表

在声明类时，对数据成员的初始化工作一般在构造函数中用赋值语句进行。此外还可以用成员初始化列表实现对数据成员的初始化。

类名::构造函数名([参数表])[:(成员初始化列表)]
{
    //构造函数体
}

析构函数

析构函数也是一种特殊的成员函数。它执行与构造函数相反的操作，通常用于撤销对象时的一些清理任务，如释放分配给对象的内存空间等。析构函数有以下一些特点：

析构函数与构造函数名字相同，但它前面必须加一个波浪号（~）。
析构函数没有参数和返回值，也不能被重载，因此只有一个。
当撤销对象（对象的生命周期结束时）时，编译系统会自动调用析构函数。

class Score{
public:
	Score(int m = 0, int f = 0);//构造函数
	~Score();       //析构函数
private:
	int mid_exam;
	int fin_exam;
};

Score::Score(int m, int f) : mid_exam(m), fin_exam(f)
{
	cout << "构造函数使用中..." << endl;
}

Score::~Score()
{
	cout << "析构函数使用中..." << endl;
}

若一个对象是使用new运算符创建的，在使用delete运算符释放它时，delete会自动调用析构函数。

玩一下

#include <iostream>
using namespace std;

class Score {
public:
	Score(int m=0) :mid_exam(m) {
		cout << "构造函数使用中..." << endl;
	}

	void setScore(int m)
	{
		mid_exam = m;
	
	}
	void showScore()
	{
		cout << "期中成绩: " << mid_exam << endl;
	}
private:
	int mid_exam;
};

int main() {
	Score a(100);
	Score b(1);
	cout << "康智" ;
	a.showScore();
	cout << "最菜的财";
	b.showScore();
	return 0;
}

结果如图

默认的构造函数和析构函数

如果没有给类定义构造函数，则编译系统自动生成一个默认的构造函数

对没有定义构造函数的类，其公有数据成员可以用初始值列表进行初始化。

class A{
public:
	char name[10];
	int no;
};

A a = {"chen", 23};
cout << a.name << a.no << endl;

拷贝构造函数

拷贝构造函数是一种特殊的构造函数，其形参是本类对象的引用。拷贝构造函数的作用是在建立一个新对象时，使用一个已存在的对象去初始化这个新对象

拷贝构造函数具有以下特点：

因为拷贝构造函数也是一种构造函数，所以其函数名与类名相同，并且该函数也没有返回值。
拷贝构造函数只有一个参数，并且是同类对象的引用。
每个类都必须有一个拷贝构造函数。可以自己定义拷贝构造函数，用于按照需要初始化新对象；如果没有定义类的拷贝构造函数，系统就会自动生成一个默认拷贝构造函数，用于复制出与数据成员值完全相同的新对象。

类名::类名(const 类名 &对象名) 
{
    拷贝构造函数的函数体；
}

class Score{
public:
	Score(int m, int f);  //构造函数
	Score();
	Score(const Score &p);  //拷贝构造函数
	~Score();               //析构函数
	void setScore(int m, int f);
	void showScore();
private:
	int mid_exam;
	int fin_exam;
};

Score::Score(int m, int f)
{
	mid_exam = m;
	fin_exam = f;
}

Score::Score(const Score &p)
{
	mid_exam = p.mid_exam;
	fin_exam = p.fin_exam;
}

调用拷贝构造函数的一般形式为：
    类名 对象2(对象1);
    类名 对象2 = 对象1;
Score sc1(98, 87);
Score sc2(sc1);    //调用拷贝构造函数
Score sc3 = sc2;   //调用拷贝构造函数

调用拷贝构造函数的三种情况：