c++(三)

已于 2024-06-09 21:28:28 修改
阅读量566 收藏 13
点赞数 24
分类专栏： c++ 文章标签： c++ 开发语言
于 2024-05-25 17:52:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuezhe_____/article/details/139166918
版权

C++（三）


在这里插入图片描述

static

c语言的static

C语言中static的作用：
1.static修饰的局部变量，延长生命周期，只初始化一次
2.static修饰全局变量(函数),限制了作用域，只能在本文件内使用

c++中的static

static修饰的成员变量

作用：实现成员变量在类中所有的对象之间的 共享

  • 在类内进行声明，类外初始化
    在这里插入图片描述
  • 初始化的格式
数据类型 类名::变量名 = 初始值;

在这里插入图片描述

-== 类中的静态成员变量，不属于某个对象，而是属于类，但是每一个对象都可以访问==

  • 访问

1、对象.成员变量
2、指针对象名->成员变量
3、类名::成员变量（需要将该成员变量放在public区）

  • static修饰的成员没有对象的时候，也可以访问
  • 当类中的数据成员的值在其他的类中要使用时，就用static修饰，不用创建对象就可以快速使用！
#include <iostream>
using namespace std;
/*
* static修饰的成员变量
* 作用：实现成员变量在类中所有对象之间共享
* 1.在类内声明，类外初始化
* 2.初始化格式：类型名 类名::变量名 = 初始值；
* 3.类中的成员变量，不属于某个对象，而属于类，但所有对象都可以访问
* 4.访问：对象.成员变量；指针对象名->成员变量；类名::成员变量
*/

class Student
{
public:
	//构造
	Student(string name = "张三");
	//析构
	~Student();
	void show();
private:
	static int count; //类内声明，类外初始化
	int id;
	string name;
protected:
};
Student::Student(string name)
{
	//访问
	this->id = Student::count++;
	this->name = name;
	cout << "**构造**" << endl;
}
Student::~Student()
{
	cout << "**析构**" << endl;
}
void Student::show()
{
	cout << "学号：" << this->id << ","
		<< "姓名" << this->name << endl;
}
//初始化格式：类型名 类名::变量名 = 初始值；
int Student::count = 1;

int main()
{
	//创建两个对象，看id是否自增
	Student student1("李四");
	student1.show();

	Student student2("王五");
	student2.show();
}

在这里插入图片描述

static 修饰成员函数

作用：实现成员函数的共享

  • 当该类中的成员函数需要在其他类中使用，此时重新new对象开销大，就可以将该成员函数设置为static
  • 静态成员函数没有this指针
  • 静态成员函数中不能访问非静态成员(成员变量、成员函数)
  • 非静态成员函数可以访问静态成员
  • static修饰的成员函数属于类，但是对象可以去调用
  • 访问

1、对象.成员函数
2、指针对象->成员函数
3、类::成员函数

#include <iostream>
using namespace std;
/*
* static修饰的成员函数
* 作用：实现成员函数的共享
* 静态成员函数没有this指针
* 静态成员函数不能访问非静态成员
* 非静态成员函数可以访问静态成员
* 静态成员的访问：对象名.静态函数;指针对象->静态函数；类::静态函数
*/
class Student
{
public:
	//构造
	Student(string name= "张三");
	//析构
	~Student();
	static void show(Student &demo);
	void show_name();
private:
	static int count;
	int id;
	string name;
protected:
};
Student::Student(string name)
{
	this->id = Student::count++;
	this->name = name;
	cout << "构造" << endl;
}
Student::~Student()
{
	cout << "析构" << endl;
}
void Student::show(Student &demo)
{
	//静态成员函数中不存在指针this
	/*cout << "学号：" << this->id << ","
		<< "姓名：" << this->name << endl;*/
	/*静态成员函数不能访问非静态成员
	show_name();*/
	//传入对象引用来实现输出
	cout << "学号：" << demo.id << ","
		<< "姓名：" << demo.name << endl;

}
void Student::show_name()
{
	//非静态成员函数可以访问静态成员
	cout << "变量：" << Student::count << endl;
	cout << "姓名：" << this->name << endl;
}
int Student::count = 1;

int main()
{
	Student student1("李四");
	student1.show(student1);
	student1.show_name();

	Student student2("王五");
	student2.show(student2);
	student2.show_name();

}

在这里插入图片描述

const

c语言

在C语言中:
const:修饰的只能读不能写
const int a;//栈区
int *p = NULL;
指针常量:int * const p = NULL;//p的指向不能修改
常量指针:int const *p = NULL;//值不能修改
const int const *p = NULL;//值和指向都不能修改

c++

const修饰成员变量

  • const修饰的成员变量只能以初始化列表的形式进行初始化
    在这里插入图片描述

  • 非const修饰的成员变量也可以以初始化列表的方式进行初始化
    在这里插入图片描述

  • const修饰的成员变量只能读不能修改
    在这里插入图片描述

#include <iostream>
using namespace std;
/** const 修饰成员变量
 * const修饰的成员变量只能以初始化列表的形式初始化
 * 非const修饰的成员变量也可以用初始化列表的形式初始化
 * const修饰的成员变量只能读不能修改
*/
class Student
{
public:    
	//构造    
	Student(int id = 1, string name = "张三", string sex = "女");    
	//析构    
	~Student();    
	void show();    
	void set_id(int id);
​private:    
	const int id;    
	string name;    
	string sex;
protected:
};
Student::Student(int id, string name, string sex):id(id),sex(sex)//非const修饰的成员变量也可以以初始化列表的形式初始化
{    
	/*const 修饰的成员变量必须以初始化列表的形式初始化    this->id = id;*/    
	this->name = name;    
	cout << "构造" << endl;
}
Student::~Student()
{    
	cout << "析构" << endl;
}
void Student::show()
{    
	cout << "学号：" << this->id << ","        			
	<< "姓名：" << this->name <<","        
	<< "性别：" << this->sex << endl;
}
void Student::set_id(int id)
{    
	/*const 修饰的成员变量不能修改    this->id = id;*/
}
​int main()
{    
	Student student1;    
	student1.show();​    
	Student student2(2, "李四", "男");    
	student2.show();
}

在这里插入图片描述

const修饰的成员函数

  • 本质：const修饰的成员函数本质上是修饰成员函数中的第一个隐藏参数this指针
void Student::set_address(string address)
//Student * const this
{
}
void Student::set_address(string address) const
//const Student * const this
{
}
  • const修饰的成员函数中，成员变量的值不能修改
    在这里插入图片描述
  • 互为重载

在这里插入图片描述

  • 非const修饰的成员函数可以访问const修饰的成员
    在这里插入图片描述
  • const修饰的成员函数不可以访问非const修饰的成员函数
    在这里插入图片描述
#include <iostream>
using namespace std;
/*
* const 修饰成员函数实质上修饰的是成员函数第一个参数this
* const 修饰的成员函数不可以修改成员变量
* const 修饰的成员函数不可以访问非const修饰的成员函数
* 非const 修饰的成员函数可以访问const修饰的成员
* const 修饰的成员函数与非const修饰的成员函数互为重载
*/
class Student
{
public:
	Student(int id = 1, string name = "张三", string sex = "女");
	~Student();
	void show();
	void set_name(string name) const;
	void set_name(string name);
	void show_name() const;
private:
	const int id;
	string name;
	string sex;
protected:
};
Student::Student(int id, string name, string sex) :id(id), sex(sex)
{
	this->name = name;
	cout << "构造" << endl;
}
Student::~Student()
{
	cout << "析构" << endl;
}
void Student::show()
{
	this->show_name();
	cout << "学号：" << this->id << "," //非const修饰的成员函数可以访问const修饰的成员
		<< "姓名：" << this->name << ","
		<< "性别：" << this->sex << endl;
}
void Student::set_name(string name) const //const Studnet * const this;指向和值都不可改变
{
	/*const修饰的成员函数不可以修改成员变量
	this->name = name;*/
	//const修饰的成员函数可以访问非const修饰的成员变量
	cout << this->name << endl;
	/*const 修饰的成员函数不可以访问非const修饰的成员函数
	this.show();*/
}
void Student::set_name(string name)//Student * const this;const修饰的成员函数与非const修饰的成员函数互为重载
{
	this->name = name;
}
void Student::show_name() const
{
	cout << this->name << endl;
}

int main()
{
	Student student1(2, "李四", "男");
	student1.show();
	
}

在这里插入图片描述

const修饰的类对象

  • const修饰类对象之后只能访问const修饰的函数
#include <iostream>
using namespace std;
/*
* const 修饰的类对象
* 只能访问const修饰的成员函数
*/

class Student
{
public:
	Student(int id = 1, string name = "张三");
	~Student();
	void show() const;
	void set_name(string name);
private:
	const int id;
	string name;
protected:
};
Student::Student(int id, string name):id(id)
{
	this->name = name;
	cout << "构造" << endl;
}
Student::~Student()
{
	cout << "析构" << endl;
}
void Student::show() const
{
	cout << "学号：" << this->id << ","
		<< "姓名：" << this->name << endl;
}
void Student::set_name(string name)
{
	this->name = name;
}

int main()
{
	const Student student1;
	student1.show();
	/*const 修饰的类对象，类对象不能访问const修饰的成员变量
	cout << student1.id << endl;*/
	/*const 修饰的类对象，类对象只能访问const修饰的成员函数
	student1.set_name();*/
	return 0;
}

在这里插入图片描述

mutable

  • 打破了const的限制
  • const修饰的成员函数中，成员变量的值不能被修改
  • 一般情况下不要使用，除非破不得已
    在这里插入图片描述
    在这里插入图片描述
#include <iostream>
using namespace std;
/*
* mutable 打破const
* 使得const修饰的成员函数可以修改mutable修饰的成员变量
*/
class Student
{
public:
	Student(int id = 1, string name = "张三");
	~Student();
	void show();
	void set_name(string name) const;
private:
	const int id;
	mutable string name;
protected:
};
Student::Student(int id, string name) :id(id)
{
	this->name = name;
	cout << "构造" << endl;
}
Student::~Student()
{
	cout << "析构" << endl;
}
void Student::show()
{
	cout << "学号：" << this->id << ","
		<< "姓名：" << this->name << endl;
}
void Student::set_name(string name) const
{
	//const 修饰的函数可以修改mutable修饰的成员变量
	this->name = name;
}

int main()
{
	Student student1;
	student1.show();
	student1.set_name("李四");
	student1.show();
	return 0;
}

在这里插入图片描述

友元

  • 友元打破了private、protected的限制
  • 私有的(受保护的)成员变量要访问在public区提供函数接口去访问的；如果访问的次数少，没有关系;如果访问的比较频繁，对系统消耗比较多；如果能直接访问的话大大提高了效率
  • 关键字：friend

普通函数作为友元

在这里插入图片描述

#include <iostream>
using namespace std;
/*
* 友元 打破private,protected
* 普通函数作为友元函数：使得普通函数可以操作类中的私有成员变量
*/
class Student
{
public:
	Student(int id = 1, string name = "张三");
	~Student();
	void show();
	friend void set_get_name(Student &denmo, string name);
private:
	int id;
	string name;
protected:
};
Student::Student(int id, string name) :id(id)
{
	this->name = name;
	cout << "构造" << endl;
}
Student::~Student()
{
	cout << "析构" << endl;
}
void Student::show()
{
	cout << "学号：" << this->id << ","
		<< "姓名：" << this->name << endl;
}
void set_get_name(Student &demo, string name)
{
	cout << "原始name：" << demo.name << endl;
	demo.name = name;
	cout << "修改后name:" << demo.name << endl;
}

int main()
{
	Student student1;
	set_get_name(student1, "王五");
	return 0;
}

在这里插入图片描述

类的成员函数作为友元

问题
在这里插入图片描述
解决：在类内声明，类外定义
在这里插入图片描述

#include <iostream>
using namespace std;
/*
* 友元 打破private,protected
* 类的成员函数作为友元函数：使得类的成员函数可以操作类中的私有成员变量
* 先声明，在类外定义
*/
class Student;
class Tea
{
public:
	void set_get_name(Student& demo, string name);
private:
	
protected:
};
class Student
{
public:
	Student(int id = 1, string name = "张三");
	~Student();
	void show();
	friend void Tea::set_get_name(Student& denmo, string name);
private:
	int id;
	string name;
protected:
};
Student::Student(int id, string name) :id(id)
{
	this->name = name;
	cout << "构造" << endl;
}
Student::~Student()
{
	cout << "析构" << endl;
}
void Student::show()
{
	cout << "学号：" << this->id << ","
		<< "姓名：" << this->name << endl;
}
void Tea::set_get_name(Student& demo, string name)
{
	cout << "原始name：" << demo.name << endl;
	demo.name = name;
	cout << "修改后name:" << demo.name << endl;
}

int main()
{
	Student student1;
	Tea tea;
	tea.set_get_name(student1, "王五");
	return 0;
}

在这里插入图片描述

友元类

  • 当A类中有多个成员函数要访问B类中的私有成员变量时
#include <iostream>
using namespace std;
/*
* 友元 打破private,protected
* 类的成员函数作为友元函数：使得类的成员函数可以操作类中的私有成员变量
* 先声明，在类外定义
*/
class Student;
class Tea
{
public:
	void set_get_name(Student& demo, string name);
	void get_id(Student& demo);
private:

protected:
};
class Student
{
public:
	Student(int id = 1, string name = "张三");
	~Student();
	void show();
	friend class Tea;
private:
	int id;
	string name;
protected:
};
Student::Student(int id, string name) :id(id)
{
	this->name = name;
	cout << "构造" << endl;
}
Student::~Student()
{
	cout << "析构" << endl;
}
void Student::show()
{
	cout << "学号：" << this->id << ","
		<< "姓名：" << this->name << endl;
}
void Tea::set_get_name(Student& demo, string name)
{
	cout << "原始name：" << demo.name << endl;
	demo.name = name;
	cout << "修改后name:" << demo.name << endl;
}
void Tea::get_id(Student& demo)
{
	cout << "id：" << demo.id << endl;
}

int main()
{
	Student student1;
	Tea tea;
	tea.set_get_name(student1, "王五");
	tea.get_id(student1);
	return 0;
}

在这里插入图片描述

little Y
关注
专栏目录
C++三角形合集
weixin_45743799的博客
03-24 6794
C++输出各种样式的三角形 *示例一（号直角三角形） #include <iostream> using namespace std; int main() { int rows; cout << "输入行数: "; cin >> rows; for(int i = 1; i <= rows; ++i) ...
C++三分法
m0_61033277的博客
07-27 2281
如果需要求出单峰函数的极值点，通常使用二分法衍生出的三分法求单峰函数的极值点。
c++三大特性
无问西东的博客
12-06 6726
C++的三大特性为：继承，多态，封装 封装可以隐藏实现细节，使得代码模块化， 继承可以扩展已存在的模块，它们目的都是为了： 代码重用。 而多态是为了实现另一个目的： 接口重用。 （1）继承。 一个对象直接使用另一个对象的属性和方法。 定义：继承就是新类从已有类那里得到已有的特性。 类的派生指的是从已有类产生新类的过程。原有的类成为基类或父类，产生的新类称为派生类或子类， 子类继承基类后，可以创建子类对象来调用基类函数，变量等 优点： 1.减少重复的代码。 2.继承是多态的前提。 3.继承增加了类的耦合性。
C++三位数重排
Shenrunchen的博客
12-15 4281
【问题描述】输入一个三位数的整数，将数字位置重新排列，组成一个尽可能大的三位数。如输入397，则输出应为973。 【输入形式】输入一个三位整数 【输出形式】输出一个三位整数 【样例输入】397 【样例输出】973 //三位数重排 #include<iostream> using namespace std; int main() { int n,a,b,c,t; cin>>n; a=n/100; b=(n/10)%10; c=n%10;//取个十百位数 if(n&g
C++三大特性
热门推荐
bitlxlx的博客
08-31 2万+
1.C++的三大特性为：继承，多态，封装  （1）继承。一个对象直接使用另一个对象的属性和方法。 优点：1.减少重复的代码。    2.继承是多态的前提。    3.继承增加了类的耦合性。 缺点：1.继承在编译时刻就定义了，无法在运行时刻改变父类继承的实现；    2.父类通常至少定义了子类的部分行为，父类的改变都可能影响子类的行为；    3.如果继承下来的子类不适合解决新问题，父
C++ 计算三角形面积
BayunQIofficial的博客
05-19 6944
刚开始学c，因为作业原因要写一段这个代码，做完了顺便分享出来。不知道有没有重复。希望能帮到一些有需要的人。 #include<iostream> #include<math.h> using namespace std; int main(){ cout<<"-----计算三角形面积！-----"<<endl;//还原原题标题 //输入部分 int x,y,z;//输入三条边变量 cout<<"第一条边:"<<endl; c
c++编程求三角形面积
徘云Patrickzc的博客
10-22 1万+
边长为a,b,c得到三角形面积公式为其中 *注意：计算三角形的面积之前，需判断所输入的三边之和是否能构成三角形 #include<iostream> #include<cmath> using namespace std; int main() { int a,b,c;float s,area; cout<<"请输入三角形三边边长，将输出三角形的面积"<<'\n'; cin>>a>>b>>c;
青少年软件编程C++三级题库(1-10)
c++信息学奥赛
10-06 2698
a_1, a_2, ..., a_N(1
C++计算三角形面积
Shenrunchen的博客
11-25 6340
【问题描述】编写一个三角形类，有计算面积，显示面积的功能等，并测试。要求有参数的构造函数. 【输入形式】主函数中输入三条边的边长. 【输出形式】输出三角形三角形的面积. 三个边由系统输入,作为构造函数的参数,输出三个边对应的三角形面积.提示:用海伦公式. 【样例输入】3 4 5 【样例输出】the area is 6. //计算三角形面积 #include<iostream> #include<cmath> using namespace std; class sjx{ pr
C++三大特点详解
qq_38378284的博客
09-10 3180
C++面向对象具有三大特点：封装、继承以及多态。 1. 封装 在面向对象的思想中，将数据和对数据的操作封装在一起——即类。 封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是通过外部接口以及特定的访问权限来使用类的成员。 2. 继承 继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码，在令子类继承父类的同时，可以重新定义某些属性，并重新某些方法，即覆盖父类的原...
C++三次贝塞尔曲线绘制源代码
01-04
C++实现的三次贝塞尔曲线绘制，可拖动控制点修改曲线形状，包含源代码和可执行文件，VS2008的工程。 C++实现的三次贝塞尔曲线绘制，可拖动控制点修改曲线形状，包含源代码和可执行文件，VS2008的工程。
C++大作业三维图形程序设计源码.zip
06-05
C++大作业三维图形程序设计源码.C++大作业三维图形程序设计源码.C++大作业三维图形程序设计源码.C++大作业三维图形程序设计源码.C++大作业三维图形程序设计源码.C++大作业三维图形程序设计源码.C++大作业三维图形...
三次样条插值函数的C++实现
12-06
用Visual Studio 2012 实现了三次样条插值函数。概述如下： [0]主要数据结构：typedef vector VECTOR [1]三次样条函数：VECTOR Spline(VECTOR Node, VECTOR Value, VECTOR x0, double c1, double c2, int CASE = 2) ...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 878
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
C 学习（4）
search7的博客
11-05 764
C语言学习，每个模块来自工作中的？？？
常用的c++特性--＞day02
m0_69093426的博客
11-06 508
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 180
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 596
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
最新发布
caridle的专栏
11-08 533
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
C++三点Gauss积分法示例：初学者指南
`p`, `q`, `r`分别代表三个不同的函数值，通过这些值计算出积分的增量，并累加到`m`中。 对于正弦函数的积分部分，代码采用了类似的方法，只是函数表达式不同，用`sin`代替了多项式的计算。这个过程同样遍历每个子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值