C++学习笔记一（重载、类）

已于 2024-02-26 21:02:50 修改
阅读量701 收藏
点赞数 1
分类专栏： C&C++ 文章标签： c++
于 2023-09-07 20:03:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45885074/article/details/132740935
版权

C++

1、函数重载

函数重载大概可以理解为，定义两个名字一模一样，但形参不一样的函数。通过传入参数可以判别具体执行哪一个函数。并且在这两个函数中，理论上可以执行截然不同的程序。
以下是一个简单的demo。

/* 
函数重载小实验——写一段代码求两个数或者三个数的平均值 
2023.9.7 
*/
#include <iostream>

using namespace std;

float average(float ,float ,float); 
float average(float ,float);

float average(float a,float b,float c)
{
	return (a+b+c)/3;
}

float average(float a,float b)
{
	return (a+b)/2;
}


int main()
{
	int choice;
	float temp1,temp2,temp3;
	float result;
	
	cout<<"please choose two or three numbers"<<endl;
	cin >> choice;
	
	if (choice == 2)
	{
		cout<<"please enter two numbers:"<<endl;
		cin >> temp1 >> temp2;  
		result = average(temp1,temp2);
	}
	else if(choice == 3)
	{
		cout<<"please enter three numbers:"<<endl;
		cin >> temp1 >> temp2 >> temp3;
		result = average(temp1,temp2,temp3);	
	}
	else {cout<<"your input is wrong!"<<endl;} 
	
	cout<<"please result is:"<<result<<endl;
	
	return 0;
}

注：cin可以通过enter或tab来分割输入。

2、类

2.1、类的方法和属性

通过class定义一个叫car的类。类里面的变量就叫做属性，函数就叫做方法。

class Car
{
public:
	int num;
	void run();		
};

2.2、类的方法的定义

在2.1中，我们声明了类中的有一个叫run的方法，但是具体到run函数里面到底在执行什么，还得再次定义一下。

void Car::run(void)
{
	cout<<"I am running"<<endl;
}

当然，如果类的方法中所实现的内容并不复杂，也大可在声明的时候直接定义了。如下:

class Car
{
public:
	int num;
	void run(){ 
		cout<<"I am running"<<endl;
	}	
};

2.3、构造器和析构器

Ⅰ、类的构造器是指，在实例化这个类之后，程序会先执行一个和类同名的方法。
Ⅱ、类的析构器是指，当类被被使用完毕之后，程序会自动执行一个名字为“类名字前加个~”的方法。
但如果像2.1那样，没有定义构造器和析构器，那程序其实也会去执行构造器和析构器里面的程序的，只是此时的程序为空。
注：实例化是将一个类变成一个实体，一个类可以被无限次实例化。

#include <iostream>

using namespace std;


class Car
{
public:
	int num;
	Car(int);   //构造器可以传输参数
	~Car(void);  //析构器不可以传输参数
	void run();		
};

//构造器
Car::Car(int temp)
{
	num = temp;
	cout<<"this car's license number is:"<<num<<endl;
}

//析构器，本代码是在main函数执行结束后才调用析构器方法的。
Car::~Car(void)
{
	cout<<"end."<<endl;
}


void Car::run(void)
{
	cout<<num<<" is running!"<<endl;
}


int main()
{
	class Car mycar(666);    //构造器的参数在实例化的时候就得赋上了
	class Car yourcar(888); //再次实例化一个类对象
	
	mycar.run();
	yourcar.run();
	
	return 0;
}

2.4、类的实例化

第一种实例化的方法：

class Car mycar;        //无参数，即便是class Car mycar();也不行 
class Car mycar(9);   //当构造器有参数时（假设参数是整形变量）

第二种实例化的方法：

Car mycar;        //无参数
Car mycar(9);    //当构造器有参数时（假设参数是整形变量）

由于第二种方法比较整洁，所以在实际运用中比较常用。那么接下来运用第二种实例化方法再来讲讲构造函数的隐式赋值。

Car mycar = 9;
Car mycar(9);

以上两句代码实现的效果是一样的，形式不同罢了。为了读起来方便，一般还是用Car mycar(9);这样的定义方式。

2.5、基类与子类

基类又称父类，也就说我们可以再定义一个类，继承父类的变量和方法。

#include <iostream>

using namespace std;


//父类 
class Car
{
public:
	int num;
	void run();		
};

//子类 
class MotorCycle:public Car
{
public:
	void hand_brake();
};

//父类的run方法 
void Car::run(void)
{
	cout<<"running"<<endl;
}

//子类的hand_brake方法 
void MotorCycle::hand_brake(void)
{
	
	cout<<"notice! I'am using the hand brake!"<<endl;
}


int main()
{
	class MotorCycle my_motor;
	my_motor.run();
	my_motor.hand_brake();

	return 0;
}

2.6、类的public、protected、private继承

public：可以被任何实体访问，也可以被子类访问，以及类的函数成员访问。
protected：不能被类的实体访问，但可以被子类访问，也可以类的函数成员访问。
private：不能被类的实体访问，不可以被子类访问，但可以被类的函数成员访问。

#include <iostream>
using namespace std;

//父类 
class Car
{
public:
	int num;
	void run();	
protected:
	int test1;	
private:
	int test2;
};

//子类 
class MotorCycle:public Car
{
public:
	void hand_brake();
};

//父类的run方法 
void Car::run(void)
{
	test1 = 1;   //✔ protected可以被类的函数成员访问
	test2 = 2;   //✔ private可以被类的函数成员访问
	
	cout<<"running"<<endl;
}

//子类的hand_brake方法 
void MotorCycle::hand_brake(void)
{
	test1 = 1;   //✔ protected可以被子类的函数成员访问
	//test2 = 2;  × private不可以被子类的函数成员访问
	
	cout<<"notice! I'am using the hand brake!"<<endl;
}


int main()
{
	class MotorCycle my_motor;
	my_motor.run();
	my_motor.num = 888;    //✔ public可以被实体访问
	//my_motor.test1 = 1;     × protected不可以被实体访问
	//my_motor.test2 = 2;     × private不可以被实体访问
	my_motor.hand_brake();

	return 0;
}

2.7、类的方法的重载

这里其实和第1章中的函数重载是一样的，只不过是类中定义两个名字一样的方法而已。

class Car
{
public:
	void run();
	void run(int);	//定义两个同名的方法，一个有整形形参，一个没有。
};


void Car::run(void)
{
	
	cout<<"running"<<endl;
}

void Car::run(int temp)
{
	
	cout<<"speed running"<<endl;
}

2.8、子类方法的覆盖

子类再次声明一个和父类一模一样的方法，用以覆盖父类的方法。但值得注意的是，这里说的覆盖并不完全准确。当我们对父类进行实列化之后，再次调用run方法，执行依旧的父类中的run方法，而不是覆盖之后子类的run。这点从子类的函数成员可以调用父类的run方法也可以看出来。通过以下两段代码希望可以加强各位的理解。
代码一：

//父类
class Car
{
public:
	void run();
};

//子类 
class MotorCycle:public Car
{
public:
	void run();
};

//父类的run方法 
void Car::run(void)
{
	cout<<"running"<<endl;
}


//子类的run方法。
void MotorCycle::run(void)
{
	car::run();         //子类的函数成员可以直接调用子类的方法
	cout<<"the motorcycle is running"<<endl;
}

代码二：

#include <iostream>

using namespace std;


//父类
class Car
{
public:
	void run();
};

//子类 
class MotorCycle:public Car
{
public:
	void run();
};

//父类的run方法 
void Car::run(void)
{
	cout<<"the car is running"<<endl;
}


//子类的run方法
void MotorCycle::run(void)
{
	cout<<"the motorcycle is running"<<endl;
}



int main()
{
	Car my_car;
	MotorCycle my_motor;
	
	my_car.run();   //调用的是父类的run方法
	my_motor.run();  //调用的是子类的run方法

	return 0;
}

2.9、继承中的构造函数和析构函数

即便是子类继承继承父类，在对子类实例化之后，也是会执行父类的构造器和析构器。但如果父类的构造器中有传入参数，则必须在子类的构造器方法中给父类的构造器传入参数，否则代码报错。

#include <iostream>

using namespace std;

class Car
{
public:
	int temp1;
	Car(int num){       //由于父类的构造器有参数，所以必须在子类中传入
		cout<<"the license plate of this car is:"<<num<<endl; 
	} 
	~Car(void){
		cout<<"the father car haved terminated!!"<<endl;
	}
};

class Little_car:public Car
{
public:
	Little_car(int num):Car(num){           //注意子类的构造器的传入参数必须和父类构造器的传入参数一样
		cout<<"i am little car"<<endl;
	}
	~Little_car(void){
		cout<<"i am the destructor of the litte car"<<endl;
	}	
};


int main()
{
	Little_car mycar(888);
	
	return 0;
}

输出结果：
在这里插入图片描述

2.10、初始化列表

初始化列表，即在执行构造函数的时候，将类的所有属性或部分属性都赋上之值。

最典型的初始化方法：
class Car
{
public:
	int _number1;
	int _number2;
	
	Car(int num)
	{
		_number1 = 3;
		_number2 = 9;
	}
};

一种比较常用且简洁的初始化方法：
class Car
{
public:
	int _number1;
	int _number2;
	
	Car(int num):
	_number1(3)
	,_number2(num)
	{
		cout<<"i am the constructor"<<endl;
	}
};

从上面这段代码可以发现，列表初始化的方式和2.9提到的子类调用父类的构造器的方式十分相似。那么下面这段代码则阐明如何同时调用父类的构造器和初始化列表。

class Car    //父类Car
{
public:	
	Car(int num):
	{
		cout<<"i am the constructor of the superclass"<<endl;
	}
};

class MotorCycle
{
public:
	MotorCycle(int num):Car(num)       //调用父类的构造器
	,_number1(num)                  //初始化列表
	,_number2(9.9)
	{
		cout<<"the first number is: "<<_number1<<endl;
		cout<<"the second number is: "<<_number2<<endl;
	}
	
private:
	int _number1;
	float _number2;
};

2.11、类的多继承

#include<iostream>

using namespace std;

class Car            //父类1：小车
{
public:	
	Car(void)
	{
		cout<<"i am the constructor of the superclass"<<endl;
	}
	void run(void){
		cout<<"running"<<endl;
	}
};

class Plane             //父类2：飞机
{
public:
	Plane(void){
		cout<<"i can fly"<<endl;
	}
	
	void fly(void){
		cout<<"flying"<<endl;
	}
protected:
	int _height;
};


class MotorCycle:public Car, public Plane     //继承小车和飞机
{
public:
	MotorCycle(int num)
	{
		_height = num;
		cout<<"i am the motorcycle, i want to fly and run"<<endl;
		cout<<"i reach the  "<<_height<<"  altitude"<<endl;
	}
};

int main()
{
	MotorCycle my_motorcycle(666);
	
	return 0;
}
__TAT__
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++学习笔记.zip
09-19
在"新建文本文档.txt"中，可能包含了学习过程中的笔记、代码示例或问题记录。而"c-master.zip"可能是某个C++项目或库的源码压缩包，可能包含多个源文件、头文件、Makefile等，通过解压和阅读这些代码，可以深入理解...
王道C++46期学习笔记记录.zip
10-18
《王道C++46期学习笔记记录》是一份详细且深入的C++学习资源，旨在帮助编程初学者以及有经验的开发者进一步提升C++技能。C++是一种强大的、通用的编程语言，以其面向对象的特性、高效性能和丰富的库支持而闻名。这46...
C++学习笔记、常见面试知识点.zip
08-04
C++学习笔记和常见面试知识点，C++11特性，包括多态、虚表、移动语义、友元函数、符号重载、完美转发、智能指针、const和static、数组指针和指针数组、struct内存对齐、enum和union关键字等等。帮助了解C++的特性，...
C++学习笔记--函数
09-08
**C++学习笔记--函数** 在C++编程中，函数是一种可重用的代码块，它执行特定的任务并可能接收参数、返回值或两者都有。本笔记将深入探讨C++中的函数，包括它们的定义、调用、参数传递以及如何在实际编程中有效地...
C++完全学习资料 手动笔记！
02-25
总结起来，这份学习资料提供了全面的C++知识体系，从基本的数组和函数，到面向对象编程的关键概念如封装、继承和多态，再到模板和STL的使用，覆盖了C++学习的各个方面。通过系统地学习这些笔记，你可以构建扎实的C++...
c++ primer plus 第16章string 类和标准模板库,string 类输入
zhyjhacker的博客
07-14 755
c++ primer plus 第16章string 类和标准模板库,string 类输入。
C++初探究（2）
Frenemy__的博客
07-09 1491
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C语言操作符详解
z317920的博客
07-11 614
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
【C++】类和对象--类，实例化，this指针
tidal_wave的博客
07-10 1010
前面的几篇文章我们介绍了命名空间，inline，nullptr等C++中常见的的基础概念。今天的文章我们来介绍一些C++中类与对象的内容。在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们建立一个集合。而这个集合就称为类。类是定义同一类所有对象的变量和方法的蓝图或原型。
C++：哈希表
m0_61088872的博客
07-12 689
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
c++ 网络编程udp协议 poco模块
m0_56306892的博客
07-11 285
1、poco是在原生socket之上的封装，底层还是socket，性能低于socket，安全性和实用性高于socket，即使用简便，接口简单。官网资料(需要梯子)：https://pocoproject.org/slides/200-Network.pdf。3、很多案例，包括官网给出的案例，端口都是514，这个端口发送是没什么限制，但是接收会出现，2、udp协议是，接收端没有及时接收或者没有接收到这个数据，数据会丢失。，解决这个问题，要么换端口，要么执行加管理员权限。
[C/C++入门][变量和运算]7、交换变量（空杯思想）
qq_14840819的专栏
07-14 379
如图，一杯牛奶，一杯咖啡，如何进行交换呢？相信懂的都懂，不懂的看完这个图也就懂了。生活中非常简单的例子，放到我们计算机中也同样适用。
[C++]——同步异步日志系统（3）
plj521的博客
07-10 1548
从本篇开始，正式开始写同步异步日志系统
C++中的多态：虚函数与纯虚函数详解
TheJustice_的博客
07-14 261
在C++中，虚函数是在基类中使用virtual关键字声明的函数。当基类指针或引用指向派生类对象时，调用虚函数将执行派生类中的版本。public:public:void display() override { // 使用 override 确保函数被正确重写纯虚函数在基类中使用virtual关键字和= 0来声明。public:// 纯虚函数。
C++静态成员
2402_84626835的博客
07-14 52
对于类中的非静态数据成员，每一个类对象都拥有一个副本，即每个对象的同名数据成员可以分别存储不同的数值，这是保证每个对象拥有区别于其他对象的特征的需要。（1）由于在类的声明中仅仅是对静态数据成员进行了引用声明，因此必须在文件作用域的某个地方对静态数据成员进行定义并进行初始化，即应在类体外对静态数据成员进行初始化（静态数据成员的初始化与它的访问控制权限无关）。静态数据成员的值对每个对象都是一样的，它的值可以被任何一个对象更新，从而实现了同一类的不同对象之间的数据共享。9.1 静态数据成员。
PointCloudLib LocalMaximum_DeleteMaxPoint C++版本
linux_huangyu的博客
07-13 27
在点云库（Point Cloud Library，PCL）中，处理点云数据时，经常需要去除局部最大点（Local Maximum），这通常用于去除噪声、提取特定形状的特征或者简化点云数据。局部最大点指的是在局部区域内，其高度（或某个特定维度上的值）高于其邻近点的点。
【C语言小知识】缓冲区
dab112的博客
07-06 862
主要讲解了缓冲区的概念
C++ 入门07：静态成员和常量成员
LF__plus的博客
07-11 1301
在前面文章的学习中，我们掌握了类和对象的基础知识以及构造函数的重载与拷贝构造函数。今天，我们将学习类的静态成员和常量成员。静态成员和常量成员是面向对象编程中重要的概念，了解它们有助于我们编写更高效和更安全的代码。
[C++]位图+布隆过滤器
最新发布
m0_71071692的博客
07-14 179
位图，就是用每一位（bit）来存放某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在的。如：数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0代表不存在。我们将每一个数据都以某种方式映射到位图中，那么一个位置就代表了其所对应的数据，一个数据只映射到其对应的位置中（一一对应）。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

__TAT__

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值