2021-6-24c++暑期1

最新推荐文章于 2024-07-22 09:38:37 发布
最新推荐文章于 2024-07-22 09:38:37 发布
阅读量147 收藏
点赞数 2
分类专栏： C语言 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42522733/article/details/118187548
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

假期即将开始，首先快速复习c++

一、命名空间

作用：防止变量或函数等重名，引起访问不明确。

//命名空间
#include<stdio.h>
#include<cstdio>

namespace Pointer1 {
	void print() {
		printf("你好");
	}

}

namespace Pointer2 {
	void print() {
		printf("hello");
	}
}
void print() {
	printf("world");
}

int main() {
	print();
	Pointer1::print();
	Pointer2::print();
	return 0;
}

usingname space pointer;可以让下面可以使用命名空间中的所有内容。
使用print函数使用::print();的方法。

std::cout<<std::endl;
endl换行并且清空缓冲区。

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

二、引用类型

目的是尽量少的指针

#include<iostream>
using namespace std;

int main(){
	int a = 100;
	int& b = a;//引用类型，b是a，a就是b
	cout << &b << " " << &a << endl;
	return 0;
}

特点：

  1. 引用被创建的同时就必须进行初始化，而指针可以在任何时候进行初始化。
  2. 不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
  3. 一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。
//实现一个函数交换两个变量
#include<iostream>
using namespace std;

void swap(int* a, int* b) {
	int t = *a;
	*a = *b;
	*b = t;
}

void swap(int& a, int& b) {
	int t = a;
	a = b;
	b = t;
}

三.函数重载

  1. 相同声明域下的函数名相同但是参数列表不同（类型和个数不完全相同）
  2. 只有返回值类型不同不算函数重载
  3. 返回值类型需要相同
//实现一个函数交换两个变量
#include<iostream>
using namespace std;

void swap(int* a, int* b) {
	int t = *a;
	*a = *b;
	*b = t;
}

void swap(int& a, int& b) {
	int t = a;
	a = b;
	b = t;
}

void swap(double& a, double& b) {
	double t = a;
	a = b;
	b = t;
}

类

类和结构体目前学习阶段认为几乎无区别，但缺省权限不同，class是私有的而struct是共有的。

#include<iostream>
using namespace std;

class Student {
public:
	int age;//成员变量（属性）
	int getAge() {//成员函数（方法）
		return age;
	}
};

类和对象

  • 类：人类 动物类 植物类
  • 对象： 家里的狗：大黄。。。

访问修饰符

  • private：私有权限的成员变量和成员函数，只能由该类中的函数、其友元函数访问，不能被任何其他访问，该类的对象也不能访问。
  • protected：可以被该类中的函数、子类的函数、以及其友园函数访问，但不能被该类对象访问
  • public：公有权限的成员变量和成员函数，可以被该类中的函数、子类的函数、其友元函数访问，也可以由该类的对象访问。
#include<iostream>
using namespace std;

class Student {
private:
	int age;//成员变量（属性）
public:
	int getAge() {//成员函数（方法）
		return age;
	}
	void setAge(int a) {
		if (a <= 0 || a > 100) {
			cout << "请输入正确年龄" << endl;
			return;
		}
		age = a;
	}

};

int main() {
	Student s;
	s.setAge(30);
	cout << s.getAge() << endl;
	return 0;
}

构造函数

  1. 构造函数是类的一种特殊成员函数，一般情况下，构造函数时专门用于初始化对成员变量的，所以最好不要在构造函数中进行与对象初始化无关的操作。
  2. 构造函数的函数名一定与类的名称完全相同，而且没有返回值（不是说返回值时void或者int而是说不允许指定返回值）。
  3. 默认存在
#include<iostream>
using namespace std;

class Student {
private:
	int age;//成员变量（属性）
public:
	Student() {
		age = 1;
	}
	Student(int a) {
		age = a;
	}

	int getAge() {//成员函数（方法）
		return age;
	}
	void growUp() {
		age++;
	}
	void setAge(int a) {
		if (a <= 0 || a > 100) {
			cout << "请输入正确年龄" << endl;
			return;
		}
		age = a;
	}

};

int main() {
	Student s;
	s.growUp();
	cout << s.getAge() << endl;
	Student s1(1);
	s1.growUp();
	coutn << s1.getAge() << endl;
	return 0;
}

析构函数

  1. 对象销毁的时候调用析构函数
  2. 默认存在
  3. 不支持函数重载
#include<iostream>
using namespace std;

class Student {
private:
	int age;//成员变量（属性）
public:
	Student() {
		age = 1;
	}
	Student(int a) {
		age = a;
	}

	~Student() {//析构函数
		cout << "game over" << endl;
	}

	int getAge() {//成员函数（方法）
		return age;
	}
	void growUp() {
		age++;
	}
	void setAge(int a) {
		if (a <= 0 || a > 100) {
			cout << "请输入正确年龄" << endl;
			return;
		}
		age = a;
	}

};

int main() {
	Student s;
	s.growUp();
	cout << s.getAge() << endl;
	return 0;
}

this

  • 区分成员变量和局部变量
  • this代表调用当前函数的对象的地址常量
#include<iostream>
using namespace std;

class Student {
private:
	int age;//成员变量（属性）
public:
	Student() {
		age = 1;
	}
	Student(int age) {
		this->age = age;
	}

	~Student() {//析构函数
		cout << "game over" << endl;
	}

	int getAge() {//成员函数（方法）
		return age;
	}
	void growUp() {
		age++;
	}
	void setAge(int a) {
		if (a <= 0 || a > 100) {
			cout << "请输入正确年龄" << endl;
			return;
		}
		age = a;
	}

};

int main() {
	Student s;
	s.growUp();
	cout << s.getAge() << endl;
	return 0;
}

拷贝构造函数

用途：通过一个对象复制出另一个对象
拷贝构造函数默认存在，拷贝构造函数和构造函数时重载的关系。
声明：

//默认的拷贝构造函数
//拷贝构造函数

class Student {
private:
	int age;
	int weight;
public:
	Student() {
		age = 1;
		weight = 8;
	}
	//拷贝构造函数,默认存在
	Student(const Student& rgh) {
		this->age = rgh.age;
		this->weight = rgh.weight;
	}
	int getAge() {
		return age;
	}
	int getWeight() {
		return weight;
	}

};

调用拷贝构造函数

  1. 对象需要通过一个对象进行初始化
//拷贝构造函数
#include<iostream>
using namespace std;
class Student {
private:
	int age;
	int weight;
public:
	Student() {
		age = 1;
		weight = 8;
	}
	//拷贝构造函数,默认存在
	Student(const Student& rgh) {
		this->age = rgh.age;
		this->weight = rgh.weight;
	}
	int getAge() {
		return age;
	}
	int getWeight() {
		return weight;
	}

};

int main() {
	Student s;
	Student s2 = s;
	cout << s.getAge() << " " << s.getWeight() << endl;
	cout << s2.getAge() << " " << s2.getWeight() << endl;
}
  1. 对象以值传递的方式传入函数参数
void printStudent(Student s2){
	cout<<s2.getAge()<<" "<<s2.getWeight()<<endl;
int main(){
	Student s;
	printStudent(s);
	return 0;
}
  1. 对象以值的传递方式从函数返回
Student getStudent(){
	Student s;
	return s;
}
int main(){
	Student s2 = getStudent();

}

return一个对象的时候会执行拷贝构造函数，因为return一个值的时候会把这个值重新复制到一个地方(临时对象)，如果将这个函数的返回值赋值给一个对象，编译器会进行优化，虽然执行了两次拷贝构造，但是会被优化为一次。

student s = getStudent();

深拷贝、浅拷贝

  • 浅拷贝
    说白了就是普普通通的值传递，传递指针之后并不会给那片区域开辟新的空间。
    在这里插入图片描述
//拷贝构造函数
#include<iostream>
using namespace std;
class Student {
private:
	int age;
	int weight;
	char* name;
public:
	Student() {
		age = 1;
		weight = 8;
		name = (char*)malloc(12);
		strcpy(name, "xiaoming");
	}
	~Student() {
		free(this->name);
	}
	//拷贝构造函数,默认存在
	Student(const Student& rgh) {
		this->age = rgh.age;
		this->weight = rgh.weight;
		this->name = rgh.name;
	}
	int getAge() {
		return age;
	}
	int getWeight() {
		return weight;
	}
	char* getName() {
		return name;
	}

};

int main() {
	Student s;
	Student s2 = s;
	cout << s.getAge() << " " << s.getWeight() << endl;
	cout << s2.getAge() << " " << s2.getWeight() << endl;
	return 0;

}
  • 深拷贝
    在这里插入图片描述
//拷贝构造函数
#include<iostream>
using namespace std;
class Student {
private:
	int age;
	int weight;
	char* name;
public:
	Student() {
		age = 1;
		weight = 8;
		name = (char*)malloc(12);
		strcpy(name, "xiaoming");
	}
	~Student() {
		free(this->name);
	}
	//拷贝构造函数,默认存在
	Student(const Student& rgh) {
		this->age = rgh.age;
		this->weight = rgh.weight;
		this->name = (char*)malloc(12);
		strcpy(this->name, rgh.name);
	}
	int getAge() {
		return age;
	}
	int getWeight() {
		return weight;
	}
	char* getName() {
		return name;
	}

};

int main() {
	Student s;
	Student s2 = s;
	cout << s.getAge() << " " << s.getWeight() << endl;
	cout << s2.getAge() << " " << s2.getWeight() << endl;
	return 0;

}

防止使用拷贝构造

  • 尽量使用引用
  • 私有化拷贝构造函数
private:
	student(const Student& rgh);

拷贝构造的参数可以传对象吗？
防止循环调用

继承

单继承

继承过来的成员，子类对象可以访问
在这里插入图片描述

#include<iostream>
using namespace std;

class People{//父类（基类）
private:
	char name[12];
protected:
	int money;
public:
	int age;
	int weight;
};
class Student: public People{//子类（派生类）
public:
	int number;
	int score;
	void print(){
		cout<<money<<weight<<endl;
	}

};
int main(){
	Student s;
	s.age = 10;
	return 0;
}

函数隐藏

  • 如果派生类中的成员（包括成员变量和成员函数）和基类中的成员重名（只要函数名相同），那么就会隐藏从基类继承过来的成员。在派生类中使用该成员，实际上使用的时派生类新增的成员而不是从基类继承来的。
  • 使用基类的成员函数
    派生类.基类：：print();
#include<iostream>
using namespace std;
class People{//父类（基类）
public :
	int age;
	int weigth;
	void print(){
		cout<<"People"<<endl;
	}
};
class Student:public People{//子类（派生类）
public:
	void print(){
		cout<<"Student"<<endl;
	}
};
int main(){
	Student s;
	s.print();
	s.People::print();
	return 0;
}

基类和派生类的构造析构顺序

#include<iostream>
using namespace std;
class People{
public:
	People(){
		cout<<"People"<<endl;
	}
	~People(){
		cout<<"~People"<<endl;
	}
};
class Student: public People{
public:
	Student(){
		cout<<"Student"<<endl;
	}
	~Student(){
		cout<<"~Student"<<endl;
	}
};
class CollegeStudent : public Student{//多重继承
public:
	collegeStudent(){
		cout<<"CollegeStudent"<<endl;
	}
	~collegeStudent(){
		cout<<"~CollegeStudent"<<endl;
	}
};

int main(){
	CollegeStudent cs;
	return 0
}

子类优先调用父类构造函数，然后调用子类的构造函数，然后调用子类的析构函数，最后调用父类的析构函数。
people，Student，~ Student，~ people

多继承

#include<iostream>
using namespace std;
class People{
protected:
	int age;
public:
	void dowork(){
		cout<<"吃饭 睡觉 打豆豆"<<endl;
	}
};
class Worker:public People{
public:
	void dowork2(){
		cout<<"板砖"<<endl;
	}
};
class Farmer: public People{
public:
	void doWork3(){
		cout<<"种地"<<endl;	
	}

};
class MigrantWorker : public Worker,public Farmer{//多继承
};
int main(){
	MigrantWorker mw;
	//mw.dowork();
	mw.doWork2();
	mw.doWork3();
	return 0;
}
  • mw.doWork()???
  • mw.age;???

虚继承

  • 为什么存在
    现象：加入我们有类A是父类，类B和类C继承了类A，而类D既继承类B又继承类C（这种菱形继承关系）。当我们实例化D的对象的时候，每个D的实例化对象中都有了两份完全相同的A的数据，因为保留多份数据成员的拷贝，不仅占用较多的存储空间，还增加了访问这些成员是的困难，容易出错，而实际上，我们并不需要有多份拷贝。
    在这里插入图片描述

  • 解决方案

#include<iostream>
using namespace std;
class People{
protected:
	int age;
public:
	void dowork(){
		cout<<"吃饭 睡觉 打豆豆"<<endl;
	}
};
class Worker:virtual public People{
public:
	void dowork2(){
		cout<<"板砖"<<endl;
	}
};
class Farmer:virtual public People{
public:
	void doWork3(){
		cout<<"种地"<<endl;	
	}

};
class MigrantWorker :virtual public Worker,virtual public Farmer{//多继承
};
int main(){
	MigrantWorker mw;
	//mw.dowork();
	mw.doWork2();
	mw.doWork3();
	return 0;
}

多态

new和malloc的区别

  1. new/delete是c++运算符那，需要编译器支持。malloc/free是库函数，需要头文件支持。
  2. 使用new操作符申请内存分配时无需指定内存的大小，编译器会根据类型信息自行计算。而malloc则需要显示地指出所需内存的尺寸。
  3. new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无需进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void*，需要通过强类型转换将void*指针转换成我们需要的类型。
  4. new内存分配失败时，会抛出bac_alloc异常。malloc分配内存失败时会返回NULL。
  5. new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。
#include<iostream>
using namespace std;

int main() {
	int* p = (int*)malloc(sizeof(int));
	p[0] = 100;
	free(p);

	int* n = new int;
	*n = 200;
	delete n;

	int* a = new int[10];
	a[8] = 10;
	delete[] a;

	return 0;

}

#include<iostream>
using namespace std;


class People {

public:
	People() {
		cout << "People" << endl;
	}
	~People() {
		cout << "~People" << endl;
	}
};

int main() {
	People* p = (People*)malloc(sizeof(People));
	free(p);

	People* n = new People;
	delete n;

	return 0;

}

再谈函数隐藏

#include<iostream>
using namespace std;


class People {

public:
	People() {
		cout << "People" << endl;
	}
	~People() {
		cout << "~People" << endl;
	}
	void play() {
		cout << "吃饭 睡觉 打豆豆" << endl;
	}
};
class Student :public People {
public:
	void play() {
		cout << "王者 吃鸡 英雄联盟" << endl;
	}
};
int main() {
	Student s;
	s.play();
	return 0;
}

函数重写/函数覆盖

  1. 父类定义虚函数
  2. 子类实现父类的虚函数
#include<iostream>
using namespace std;


class People {

public:
	People() {
		cout << "People" << endl;
	}
	~People() {
		cout << "~People" << endl;
	}
	virtual void play() {
		cout << "吃饭 睡觉 打豆豆" << endl;
	}
};
class Student :public People {
public:
	void play() {
		cout << "王者 吃鸡 英雄联盟" << endl;
	}
};
int main() {
	Student s;
	s.play();
	return 0;
}

多态的实现

  1. 函数重写/函数覆盖
  2. 父类指针指向子类对象，并且调用子类的重写函数（运行的就是子类函数）
#include<iostream>
using namespace std;


class People {

public:
	People() {
		cout << "People" << endl;
	}
	~People() {
		cout << "~People" << endl;
	}
	virtual void play() {
		cout << "吃饭 睡觉 打豆豆" << endl;
	}
};
class Student :public People {
public:
	void play() {
		cout << "王者 吃鸡 英雄联盟" << endl;
	}
};
class Farmer :public People {
public:
	void paly() {
		cout << "玩地" << endl;
	}
};
int main() {
	Student s;
	People* p = (People*)&s;
	p->play();
	//1.函数隐藏，调用的是哪个函数由指针变量类型决定
	//2.函数重写，调用的是哪个函数由指针变量中存放的地址类型决定。
	return 0;
}

多态的应用场景

  1. 存储

#include<iostream>
using namespace std;


class People {

public:
	People() {
		cout << "People" << endl;
	}
	~People() {
		cout << "~People" << endl;
	}
	virtual void play() {
		cout << "吃饭 睡觉 打豆豆" << endl;
	}
};
class Student :public People {
public:
	void play() {
		cout << "王者 吃鸡 英雄联盟" << endl;
	}
};
class Farmer :public People {
public:
	void paly() {
		cout << "玩地" << endl;
	}
};
int main() {
	Student s;
	Student s2;
	Student s3;
	Farmer f1;
	Farmer f2;
	Farmer f3;
	People p1;
	People p2;
	People p3;
	People* vector[10] = {&s,&s2,&s3,&f1,&f2,&f3,&p1,&p2,&p3};
	for (int i = 1; i < 10; i++) {
		if (vector[i]) {
			vector[i]->play();//不用判断
		}
	}
	return 0;
}
  1. 参数
#include<iostream>
using namespace std;


class People {

public:
	People() {
		cout << "People" << endl;
	}
	~People() {
		cout << "~People" << endl;
	}
	virtual void play() {
		cout << "吃饭 睡觉 打豆豆" << endl;
	}
};
class Student :public People {
public:
	void play() {
		cout << "王者 吃鸡 英雄联盟" << endl;
	}
};
class Farmer :public People {
public:
	void paly() {
		cout << "玩地" << endl;
	}
};
void printInfo(People* p) {
	p->play();
}
int main() {
	Student s;
	Student s2;
	Student s3;
	Farmer f1;
	Farmer f2;
	Farmer f3;
	People p1;
	People p2;
	People p3;
	printInfo(&s2);
	return 0;
}

静态成员

静态成员变量

#include<iostream>
using namespace std;
class People {
public:
	int age;
	static int water;//静态成员变量属于类而不属于对象
};
int People::water = 100;//类外初始化

int main() {
	People p1;
	People p2;
	p1.water--;
	People::water--;
	cout << People::water << endl;
	return 0;
}

静态成员函数

#include<iostream>
using namespace std;
class People {
private:
	int age;
	static int water;//静态成员变量属于类而不属于对象
public:
	static void drink() {
		water--;
	}
	static int getWater(){
		return water;
	}
};
int People::water = 100;//类外初始化

int main() {
	People p1;
	People p2;
	People::drink();
	cout << People::getWater()<< endl;
	return 0;
}

缺省函数参数

#include<iostream>
using namespace std;
class Employee {
public:
	Employee(int a, int b = 0, int c = 2) {
		cout << "Employee" << endl;
	}
};

int main() {
	Employee(1);
	return 0;
}

多态实例

//多态实例

#include<iostream>
#include<string>
using namespace std;

class Employee {
protected:
	int m_id;    //对象id
	string m_name;
	double m_salary;
	static int id;//类id
public:
	Employee() {
		id++;
		m_id = id;
		m_name = "default name";
		m_salary = 0.0;
	}
	virtual ~Employee() {
	}
	virtual double getPay() = 0;//纯虚函数，拥有纯虚函数的类叫做抽象类，抽象类不能被实例化。
	virtual void show() {
		cout << "姓名" << m_name << " ID:" << m_id << " 工资： " << getPay() << endl;
	}
};
int Employee::id = 1000;

class Manager : virtual public Employee {
protected:
	double m_base;

public:
	Manager() {
	}
	Manager(string name) {
		m_name = name;
		m_base = 8000;
	}
	double getPay() {
		m_salary = m_base;
		return m_salary;
	}
};
class Technician :public Employee {
protected:
	int m_hour;
public:
	Technician(string name, int hour = 0) {//缺省函数参数
		m_name = name;
		m_hour = hour;
	}
	double getPay() {
		m_salary = m_hour * 100;
		return m_salary;
	}
};
class SalesMan :virtual public Employee {
protected:
	double m_saleVolume;
	static double totalSaleVolume;
public:
	SalesMan() {
	}
	SalesMan(string name, double volume = 0.0) {
		m_name = name;
		m_saleVolume = volume;
		totalSaleVolume += m_saleVolume;
	}
	double getPay() {
		m_salary = m_saleVolume * 4 / 100;
		return m_salary;
	}
};
double SalesMan::totalSaleVolume = 0.0;

class SalesManager :public SalesMan, public Manager {
public:
	SalesManager(string name){
		m_base = 5000;
		m_name = name;
	}
	double getPay() {
		m_salary = m_base + totalSaleVolume * 5 / 100;
		return m_salary;
	}
};

int main(){
	Manager m("hjm");
	m.show();
	Technician t1("gsp", 160);
	t1.show();
	Technician t2("shg", 180);
	t2.show();
	SalesMan s1("lmh", 100000);
	s1.show();
	SalesMan s2("lzy", 200000);
	s2.show();
	SalesMan s3("mcl", 250000);
	s3.show();
	SalesManager sm("mlh");
	sm.show();
	return 0;
}

纯虚函数

虚函数=0；
拥有纯虚函数的类成为抽象类，不能实例化
子类如果没有实例化父类的纯虚函数，那么子类也是抽象类

虚析构

virtual+析构函数

  1. 为什么要加虚析构
    父类指针new子类对象，不会执行子类的析构函数，可能导致资源泄露。
  2. 为什么默认析构函数不是虚析构？
    虚函数，会产生一个虚指针，浪费空间

虚指针

虚函数列表

内部类

#include<iostream>
using namespace std;
class People {
public:
	class Baby {//在类内定义使用
	public:
		int age;
	};
	Baby b;
};

int main() {
	People p;
	p.b.age = 1;
	People::Baby baby;//外部类名+作用域+内部类名
	return 0;
}

内联函数

#include<iostream>
using namespace std;
class People {
	int money;
public:
	inline void print() {
	//访问速度快（相当于是宏）1.短小 2.使用频率高
		cout << money << endl;
	}
};

int main() {
	People p;
	p.print();
	return 0;
}

友元

友元函数

#include<iostream>
using namespace std;
class People {
private:
	int age = 100;
public:
	void printAge() {
		cout << this->age << endl;
	}
	friend void printAge();//友元函数
	friend int main(); //破坏了类的封装性
};
void printAge() {
	People p;
	cout << p.age << endl;
}
int main() {
	People p;
	cout << p.age << endl;
	return 0;
}

友元类

#include<iostream>
using namespace std;
class People {
private:
	int age = 100;
public:
	void printAge() {
		cout << this->age << endl;
	}
	friend class Animal;//友元类
};
class Animal {
private:
	People p;
public:
	void printPeopleAge() {
		cout << p.age << endl;
	}
};

int main() {

	return 0;
}

常函数

#include<iostream>
using namespace std;
class People {
private:
	int money;
public:
	void print() const{
		cout << money << endl;
		//money = 10;//不可以修改类属性
	}
};


int main() {
	People p;
	p.print();
	return 0;
}

重载运算符

c++允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。重载的运算符是带有特殊名称的函数，函数名是由关键字operator和其后要重载的运算符符号构成的，与其他函数一样，重载运算符有一个返回类型和一个参数列表。

//小任务
//Box.cpp
#include"box.h"

void Box::setBreadth(double bre)
{
	breadth = bre;
}
void Box::setHeight(double hei)
{
	height = hei;
}
//重载 + 运算符， 用于把两个Box对象相加
Box::Box() = default;
Box::Box(const Box& box)
{
	this->height = box.height;
	this->breadth = box.breadth;
	this->length = box.length;
}

Box::Box(const Box& box)
{
	this->height = box.height;
	this->breadth = box.breadth;
	this->length = box.length;
}
Box Box::operator=(const Box& b) {
	height = b.height;
	breadth = b.breadth;
	length = b.length;
}
Box Box::operator+(const Box& b) 
{
	Box box;
	box.length = this->length + b.length;
	box.breadth = this->breadth + b.breadth;
	box.height = this->height + b.height;
	return box;
}
Box Box::operator++() {
	this->length += 1;
	this->breadth += 1;
	this->height += 1;
	return *this;
}
Box Box::operator++(int) 
{
	Box tmp = *this;
	this->length += 1;
	this->breadth += 1;
	this->height += 1;
	return tmp;
}



//Box.h
#pragma once
class Box
{
public:
	double getVolume(void);//球体积

	void setLength(double len);//设置长

	void setBreadth(double bre);//设置宽

	void setHeight(double hei);//设置高度

	//重载 + 运算符，用于把两个box对象相加；
	Box();
	Box(const Box& box);

	Box operator=(const Box& b);
	
	Box operator+(const Box& b);
	
	Box operator++();//重载 前++
	
	Box operator++(int);//重载 后++

private:
	double length; //长度
	double breadth;//宽度
	double height; //高度
};
//main.cpp
#include<iostream>
#include "Box.h"
using namespace std;

//程序的主函数
int main() {
	Box box1;
	box1.setBreadth(6.0);
	box1.setHeight(6.0);
	box1.setLength(9.0);

	Box box2(box1);

	return 0;
}

总结

就这样第一天过去了。
銘澤
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多条目展示+视频播放
Chen___tao的博客
12-21 1万+
compile 'com.android.support:design:26.+' compile 'com.hjm:BottomTabBar:1.1.1' compile 'com.jakewharton:butterknife:7.0.1' compile 'io.reactivex:rxandroid:1.1.0' compile 'com.squareup.retrofit2:retrof
STM8L--IIC通信--AT24C02 模拟IIC+库函数IIC
10-30
在本文中，我们将深入探讨如何在STM8L微控制器上实现IIC通信，特别是与AT24C02 EEPROM进行交互，同时讨论模拟IIC和库函数IIC两种方法。 IIC（Inter-Integrated Circuit），也称为I2C，是一种由飞利浦（现为NXP ...
2021-09-23
Lfh的博客
09-23 746
文章目录1.文章概述1.1设计目的1.2设计任务1.3设计要求2.总体概述3.硬件原理3.1数码管与发光二极管3.2非遗失储存3.3导航键与按键3.4 蜂鸣器3.5串口通信4.软件设计与实现5.软件过程与测试6.设计心得 1.文章概述 1.1设计目的 伴随着社会的发展和科技的进步，人们对生活品质要求越来越高，隐私防范意识也越来越强，为了进一步加强自身对单片机相关知识的理解，同时也为了进一步便捷人们的生活。 在项目整体的设计过程中熟悉“STC 学习板”的相关知识，学习数码管、按键、蜂鸣器、非易失存储器 24C
暑假休息8.3---8.13 立创EDA
doctorlyly的博客
08-14 294
暑假了，去平邑菏泽都住了几天 8.3–8.13 中间还用立创EDA 画了原理图 要求如下 1、220 V 输入，9V输出 2、9V DC-DC 3.3V3、MSP430FR6989 4、利用MAX3232 增加一个串口 5、利用485芯片增加一个485的输出；6、AT24C02 DS18B20 7、增加一个DS1302 8、增加一个蜂鸣器。 急中生智 用立创的在线EDA画的 不过也有下载的离线的 我还是用的离线版的 想找什么器件 直接一搜就行了 太方便了 不过画PCB图 要是复杂的 就不大行了 可以先初
AT24C02（I2C总线）_AT24C02数据存储）
levelsss的博客
06-14 7366
AT24C02（I2C总线）_AT24C02数据存储&秒表（定时器扫描按键数码管）小白极客的51单片机笔记（自用）第一部分—存储器介绍第二部分—AT24C02存储芯片介绍第三部分—I2C总线介绍（重点）第四部分—AT24C02数据帧如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 小白极客的51单
服务器重装esxi会怎么样,记录我的家庭服务器（2）esxi6.7安装+群晖+rdm直通+踩坑记录...
weixin_34732771的博客
07-29 1638
记录我的家庭服务器(2)esxi6.7安装+群晖+rdm直通+踩坑记录2021-05-02 19:19:3960点赞657收藏66评论创作立场声明：商品来源自掏腰包，大出血，文章有部分参考其他大佬教程，本人小白，勿喷。购买理由前文说过 在学校的时候 家里的unraid系统突然连接不上了，远程重启无果 因此打算一步到位 上服务器主板(主要是馋服务器的ipmi)。 51到家发现，原来是从小学陪伴我到大...
数据与分析工程师的养成---第一次知识分享--Python的多线程与多进
inner_peace_as_water的博客
04-01 200
选这个题目的原因大概是我本来就比较喜欢底层的操作系统甚至更底层的系统架构这方面的东西。因为之前所学有限，我对多线程和多进程的第一印象是去年暑假实习时候室友做的“MPI并行程序设计”，之前也没有专门去了解这方面的东西，今天查了一下。 MPI的全称是Message-Passing-Interface,中文意思是消息传递接口。MPI并不是一种新开发的语言，他是一个定义了可以被C\C++\For...
【51单片机】普中A2开发板 模块化编程 单片机入门 实例教学目录
m0_62569287的博客
10-20 6090
四、模块化编程1.延时函数2.数码管显示3. LCD16024.矩阵按键5.独立按键6.定时器07.串口通信 8.点阵9. DS130210.蜂鸣器11. AT24C02读写数据12. AT24C02 I2C通信13. DS18B20单总线14. DS18B20温度传感器15.定时器按键(十十二用到)四、LCD1602
基于51单片机的多个DS18B20温度调节系统设计
QSNH0130的博客
07-22 2028
1.测量温度范围在-55°-125°，精度为0.1度；2.通过LCD1602动态显示温度值；3.能通过独立按键设置温度上下限；4.根据温度上下限设置，具备声光报警功能；5.能在同一个IO中连接4个DS18b20,通过DS18B20中独特的序列号进行识别和检测温度；6.能通过矩阵键盘切换DS18B20显示；
Linux 命令缩写及参数
join_yuan的博客
05-20 1580
(45条消息) Linux中常用的命令都是哪些单词的缩写_yangzongjie的博客-CSDN博客 (45条消息) Linux中常用的命令都是哪些单词的缩写_yangzongjie的博客-CSDN博客 (45条消息) Linux中常用的命令都是哪些单词的缩写_yangzongjie的博客-CSDN博客 https://blog.csdn.net/yangzongjie/article/details/78976495 这么用心的一篇博客太强大了，读到半夜没读完，留在这里以后慢慢品吧 这个原作太强
Proteus仿真IIC-24C04与蜂鸣器+代码+DSN
06-20
基于89C51单片机/89C52单片机通用的IIC-24C04与蜂鸣器，Proteus软件测试运行环境7.8版本，包含内容：keil vision5项目文件、C语言程序源码、hex后缀编译文件、DSN仿真后缀文件项目
LM3S101最小系统+AT24C02+MAX811+AS1117-3.3+JTAG+按键+LED灯组成的原理图和PCB
05-01
1. **LM3S101微控制器**：LM3S101是德州仪器（Texas Instruments）生产的一款基于ARM Cortex-M3内核的32位微控制器。它具有高速处理能力，内置闪存、SRAM和多种外设接口，适用于嵌入式应用。LM3S101通常用于控制系统...
AT89S52+AT24C010+DAC0832+MAX7128SLC84-15+按键+LCD+7805组成的原理图和PCB电路
04-30
首先，AT24C010是I²C接口的电可擦除可编程只读存储器（EEPROM）。它拥有1024字节的存储空间，常用于存储配置参数或非易失性数据，与AT89S52通过I²C总线通信，允许单片机读写数据。 接着，DAC0832是一个8位数字...
24c01-24c16读写驱动程序-24c01- 24c16 literacy Driver.zip
10-11
《24C01与24C16 EEPROM的读写驱动程序详解》 在电子工程领域，24C01和24C16是常见的电可擦除可编程只读存储器（EEPROM）芯片，它们广泛应用于各种设备中进行数据存储。24C01提供1K位（128字节）的存储空间，而24C16...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1133
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1130
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 972
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
最新发布
zeyeqianli的博客
07-22 325
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
陈老师教你入门：HL-2 AVR单片机24C02 I2C总线视频教程
教程重点介绍了24C02 IIC总线技术，这是一种由Philips公司推出的串行通信标准，因其简单、高效和低成本而被广泛应用。 IIC总线（Inter-Integrated Circuit Bus）是一种双向二线制总线，允许多个设备共享，具有仲裁...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值