C++特殊成员

最新推荐文章于 2024-07-25 21:43:46 发布
最新推荐文章于 2024-07-25 21:43:46 发布
阅读量840 收藏
点赞数
分类专栏： C++笔记 文章标签： c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54492880/article/details/121527804
版权

目录

一、const成员

        1.const数据成员

        2.const成员函数

        3.const对象

二、static成员

        1.static数据成员

  2.static成员函数

3.static对象

三、友元

        1.友元的定义

        2.友元函数

        3.友元类

        4.互为友元类(增加)

四、this指针与explicit

        1.explicit作用

        2.this指针

一、const成员

        1.const数据成员

                (1).const类型变量是不可修改的(只读模式).

                (2).必须采用初始化参数列表的方式进行初始化.

class Person
{
public:
	Person(string name,int age) :age(age)
	{
		Person::name = name; //可以这样赋值，也可以用初始化参数列表方法
		//Person::age = age; --->报错，const修饰的参数只能用初始化参数列表方式进行初始化
	}
protected:
	string name;
	const int age;
};

        2.const成员函数

                (1).写法上，const要加在函数后面

                (2).常成员函数不能修改数据成员(只读数据成员)

void print()const//常成员函数
	{
		//name = "修改"; --->报错，常成员函数中不能修改数据
		//age = 19; -->常成员数据也不能修改
		cout << "常成员函数" << endl;
	}

                (3).常成员函数可以与普通函数同时存在

void print()//普通函数
	{
		//age = 1001; --->错误 只读模式 不能修改
		cout << name << " " << age << endl;
	}
	void print()const//常成员函数
	{
		//name = "修改"; --->报错，常成员函数中不能修改数据
		//age = 19; -->常成员数据也不能修改
		cout << "常成员函数" << endl;
	}

注： ● 普通函数和常成员函数相同时,普通对象优先调用普通函数

        ● 普通对象可以调用常成员函数

        3.const对象

                (1).定义：const修饰的对象

                (2).常对象只能调用常成员函数

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person(string name,int age) :age(age)
	{
		Person::name = name; //可以这样赋值，也可以用初始化参数列表方法
		//Person::age = age; --->报错，const修饰的参数只能用初始化参数列表方式进行初始化
	}
	void print()//普通函数
	{
		//age = 1001; --->错误 只读模式 不能修改
		cout << name << " " << age << endl;
	}
	void print()const//常成员函数
	{
		//name = "修改"; --->报错，常成员函数中不能修改数据
		//age = 19; -->常成员数据也不能修改
		cout << "常成员函数" << endl;
	}
	void printData()
	{
		cout << "普通函数" << endl;
	}
protected:
	string name;
	const int age;
};
int main()
{
	Person MM("Miss Du", 19);
	MM.print();//普通对象优先调用普通函数
	//两者都有时只能调用普通函数，无法强行调用常成员函数
	//若只有常成员函数也可以调用常成员函数
	const Person GG("Mr Y", 19);
	GG.print();//输出常成员函数  常对象调用常成员函数
	//GG.printData();---->常对象只能调用常成员函数
	while (1);
	return 0;
}

二、static成员

     注：● static成员不属于对象，是属于类的，这意味着static成员是属于所有对象的(共有的)，调用时可以不用对象(也可以通过对象访问).

            ● static成员依旧受权限限定.

        1.static数据成员

                (1).必须在类外初始化，初始化时不再需要static修饰，但是需要类名限定.

                (2).类中初始化是错误的，不能采用初始化参数列表方式初始化.

class Person
{
public:
	
	//Person(int age):age(age){}  
//-->age不是类的非静态数据成员或者基类，因此在类内初始化或者用初始化参数列表初始化都不可以
protected:
	string name;
	static int age;
};
//类外初始化，不再需要static修饰，但是需要类名限定
int Person::age = 1;

  2.static成员函数

                (1).样式：static写在函数前面即可

                (2).调用非静态成员时必须要指定对象.

class Person
{
public:
	
	//Person(int age):age(age){}  
	//---->age不是类的非静态数据成员或者基类，因此在类内初始化或者用初始化参数列表初始化都不可以
	Person(string name) :name(name)
	{
		age++;
	}
	static void printMM();//类外实现--->静态函数
	static void printData(Person& MM)//类内声明，类内实现，可以通过对象的引用访问name数据成员
	{
		cout << MM.name << '\t' << age << endl;
	}
protected:
	string name;
public:
	static int age;
};
//类外初始化，不再需要static修饰
void Person::printMM()
{
	//调用非静态数据成员，必须要指定对象
	//cout << name << endl; --->当这个函数不采用对象去调用，name没有来源,报错
	Person MM("Miss DU");
	cout << MM.name << endl;
	//静态数据成员可直接调用,也可以通过对象调用
	cout << age << endl;
	cout << MM.age << endl;
	cout << "静态成员函数" << endl;
}

3.static对象

         注：释放是最后释放的

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	//Person(int age):age(age){}  
	//---->age不是类的非静态数据成员或者基类，因此在类内初始化或者用初始化参数列表初始化都不可以
	Person(string name="") :name(name)
	{
		age++;
	}
	static void printMM();//类外实现
	static void printData(Person& MM)//类内声明，类内实现，可以通过对象的引用访问name数据成员
	{
		cout << MM.name << '\t' << age << endl;
	}
protected:
	string name;
public:
	static int age;
};
//类外初始化，不再需要static修饰，但是需要类名限定
int Person::age = 18;
//类外初始化，不再需要static修饰
void Person::printMM()
{
	//调用非静态数据成员，必须要指定对象
	//cout << name << endl; --->当这个函数不采用对象去调用，name没有来源,报错
	Person MM("Miss DU");
	cout << MM.name << endl;
	//静态数据成员可直接调用,也可以通过对象调用
	cout << age << endl;
	cout << MM.age << endl;
	cout << "静态成员函数" << endl;
}
int main()
{
	
	//静态数据成员访问可以不用对象调用
	cout << Person::age << endl;
	//静态数据成员可以通过对象去访问
	Person MM("Miss Du");
	cout << MM.age << endl;				//age=20
	//静态数据成员是共有的
	Person GG[3];						//age=23;
	Person* pMM = new Person("newMM");	//age=24
	cout << Person::age << endl;		//age=24
	cout << pMM->age << endl;			//age=24
	cout << MM.age << endl;				//age=24
	delete pMM;
	pMM = nullptr;

	cout << endl;
	//静态成员函数
	Person::printMM();
	MM.printMM();				//---->三者等价
	Person::printData(MM);
	while (1);
	return 0;
}

三、友元

        1.友元的定义

                ● friend描述的关系.友元只是提供一个场所，赋予对象具有打破类的权限定(无视权限).

                ● 可以理解为朋友的是自己的，自己的也是自己的.(自我理解，或许有误)              

        2.友元函数

                (1).普通友元函数

#include<iostream>
#include<string>
using namespace std;
void printData();//声明
class Person
{
public:
	Person(string name, int age) :name(name), age(age){}
	void print()
	{
		cout << name << '\t' << age << endl;
	}
	friend void printData()
	{
		//不属于类，不能直接访问成员  ---> 对非静态成员"Person::name"的非法引用
		//cout << name << '\t' << age << < endl;
		//友元函数提供一个场所，让对象无视权限
		Person GG("Mr Y", 19);
		cout << GG.name << '\t' << GG.age << endl;
	}
protected:
	string name;
private:
	int age;
	friend void printData2(Person& MM);//类内声明
};
//类外实现友元函数--->//不需friend修饰，不需要类名限定
void printData2(Person& MM)
{
	cout << MM.name << '\t' << MM.age << endl;
}
//void printData()
//{
//	//不属于类，不能直接访问成员  ---> 对非静态成员"Person::name"的非法引用
//	//cout << name << '\t' << age << < endl;
//	//友元函数提供一个场所，让对象无视权限
//	Person GG("Mr Y", 19);
//	cout << GG.name << '\t' << GG.age << endl;
//}
int main()
{
	Person MM("Miss Du", 19);
	MM.print();
	printData();	//直接调用友元函数
	printData2(MM);
	while (1);
	return 0;
}

                (2).若以另一个类的成员函数充当友元函数，顺序如下：

                        ● B类--->A类--->A类的友元函数(B类的成员函数) 

class B
{
public:
	void printA();
	void printData();
protected:
};
class A
{
public:
	friend void B::printA();
protected:
	string name = "A";
};
//成员函数实现，一定是在另一个类的下面实现
void B::printA()
{

	A a;
	cout << a.name << endl;
}
void B::printData()
{
	A a;
	错误 ，不是他的A类的友元函数，所以不能访问保护和私有属性
	//cout << a.name << endl;
}

        3.友元类

                注：一个类是另一个类的友元类                

#include <iostream>
#include<string>
using namespace std;
class Person
{
	friend class MM;
public:
	Person(string name, int age) :name(name), age(age){}
protected:
	string name;
	int age;

};
class MM
{
public:
	void print()
	{
		Person mm("Miss Du", 19);
		cout << mm.name << "\t" << mm.age << endl;
	}
	void printMM(Person& mm)
	{
		cout << mm.name << "\t" << mm.age << endl;
	}
	Person& printmm(Person& mm)
	{
		return mm;
	}
protected:

};
int main()
{
	Person mm("Miss Du", 19);
	MM mm2;
	mm2.print();
	//mm2.printMM(mm);
	//cout<<(mm2.printmm(mm)).name<<endl; --->错误，出了友元类，没有权限
	while (1);
	return 0;
}

        4.互为友元类(增加)

#include <iostream>
#include<string>
using namespace std;
//互为友元类
class Person
{
	friend class MM;
public:
	Person() = default;
	Person(string name, int age) :name(name), age(age){}
	//void printData()//无法在此处写打印MM的数据，因为会显示MM没有定义
	//{
	//	MM mm("Miss Du", 19);
	//	cout << mm.name << "\t" << mm.age << endl;
	//}
	void printData();//可以通过类内定义，类外实现
protected:
	string name;
	int age;
};
class MM
{
	friend class Person;
public:
	MM(string name, int age) :name(name), age(age){}
	void printData()
	{
		Person gg("Mr Y", 19);
		cout << gg.name << "\t" << gg.age << endl;
	}
protected:
	string name;
	int age;
};
void Person::printData()
{
	MM mm("Miss Du", 19);
	cout << mm.name << "\t" << mm.age << endl;
}
int main()
{
	Person mm1;
	mm1.printData();
	MM mm2("Miss Du", 19);
	mm2.printData();
	while (1);
	return 0;
}

四、this指针与explicit

        1.explicit作用

                ● 修饰构造函数使用，不让隐式转换构造

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	explicit Person(int age) :age(age){}
	explicit Person(string name, int age) :name(name), age(age){}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};
class MM
{
public:
	MM(string name) :name(name){}
	MM(string name, int age) :name(name), age(age){}
	void print()
	{
		cout << name << "\t" << age << endl;
	}
protected:
	string name;
	int age;
};
int main()
{
	//explicit 不让隐式转换构造
	//Person mm3 = 12;--->不存在从“int”转换为“Person”的适当构造函数
	Person mm1(19);		//可以如此初始化
	MM mm = "Miss Du";	//可以如此初始化
	while (1);
	return 0;
}

        2.this指针

                ● 避免形参名和数据成员同名，通指对象的地址

                ● 充当函数返回值，返回对象自身，用*this表示对象本身

                ● 静态成员函数中是不能使用this指针

#include<iostream>
#include<string>
using namespace std;
class MM
{
public:
	MM(string name) :name(name){}
	MM(string name, int age) :name(name), age(age){}
	void initData(string name, int age)
	{
		//普通函数不存在初始化参数列表方法--->使用this指针
		this->name = name;
		//类名限定 帮助计算机去识别
		MM::age = age;

	}
	void print()
	{
		cout << this->name << "\t" <<this->age << endl;
	}
	void printThis()
	{
		cout << this << endl;
	}
	MM returnMM()
	{
		return *this;
	}
	static void printMM3()
	{
		//cout << this->name << endl;--->this只能用于非静态成员函数内部
		MM mm("Miss Du", 20);
		cout << mm.name << "\t" << mm.age << endl;
	}

protected:
	string name;
	int age;
};
int main()
{
	MM mm("Miss Du",19);
	mm.print();
	mm.initData("Mr Y", 20);
	mm.print();
	cout << &mm << endl;
	mm.printThis();//this为对象的地址
	MM mm2("dmw", 19);
	cout << &mm2 << endl;
	mm2.printThis();
	
	MM::printMM3();
	while (1);
	return 0;
}

demons and monsters
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++类中一些常见的成员
weixin_34342578的博客
05-05 658
注：以下为个人见解，有可能错误，欢迎批评指出！ C++的成员分类： 按照成员在类中扮的角色分： 　　　　数据成员、成员函数。 按照成员自身的使用特性分：//特性：特殊性质 　　　　普通成员、静态成员、常量成员、友元、对象成员 下以成员自身使用特性来分别介绍 一、普通成员 　　 即前面所学，不再做介绍。 二、静态成员 　　A.静态数据成员 　　...
C++-------类成员数组
dianxiangse7599的博客
05-28 4150
//MyArray.h #pragma once #include <iostream> using namespace std; class MyArray { public: MyArray(); MyArray(int len); //创建一个len长度的数组 MyArray(const ...
类和对象2
nwpuyxf的博客
03-05 97
深拷贝与浅拷贝 浅拷贝：简单的赋值拷贝操作 如果被拷贝对象有指针变量，拷贝的指针变量依旧逐字逐句，不会改变，即两个对象将会指向同一块堆区内存 如果在析构中存在释放堆区内存的代码，那么先操作的会释放，而后操作的由于该内存已经被释放，找不到，将是非法操作 即堆区内存的重复释放 深拷贝：在堆区重新申请空间，进行拷贝操作 自己实现拷贝构造函数，解决浅拷贝带来的问题 举例 person(const person &p) { m_age=p.m_age;//int变量没有差别 ...
C/C++知识点整理
Suqing_2018的博客
02-26 564
一、const 修饰常量，比如 const int a = 10，说明该变量无法被修改 修饰指针，包括指向常量的指针和指针常量 指向常量的指针：const int *p = &a; 无法通过指针修改其所指变量的值（可以指向const 和 非const） 指针常量：int *const p = &a; 不能修改指针中保存的地址 常量引用，避免拷贝，同时无法通过函数对值修改void ...
常成员 C++ const
pipi的博客
06-20 276
常成员 类的数据成员和成员函数可以声明为const，分别称为常数据成员和常成员函数 常数据成员只能通过构造函数的初始化列表进行初始化，不能被赋值或更改 const int Hour; //非静态数据成员 Time::Time(int h):Hour(h){} //正确 Time::Time(int h){Hour=h;} //错误 常数据成员是数组时，初始化方法如下： //a.h class ...
常成员函数中静态成员可以改变
JTR502的博客
05-14 1535
可以改变，原因是static成员不属于对象，可以用常函数改变 #include &lt;iostream.h&gt; class A { public: static int i; int j; int fun() const{ i+=1; return i;} // int fun1() const{ j+=1; return j;} //该函数报错 };...
详解c++ 静态成员变量
12-17
C++中的静态成员变量是一种特殊的成员，它们不与任何特定的对象实例相关联，而是属于类本身。静态成员变量的声明通常在类定义内部，而定义和初始化则需要在类的外部进行，这是因为它们的生命周期贯穿整个程序，而...
C++类中的特殊成员函数示例详解
01-21
C++类中有几个特殊的非静态成员函数，当用户未定义这些函数时，编译器将给出默认实现。C++11前有四个特殊函数，C++11引入移动语义特性，增加了两个参数为右值的特殊函数。这六个函数分别是： 1、默认构造函数 默认...
C++类的静态成员初始化详细讲解
09-05
在C++编程语言中，类的静态成员是一个特殊类型的成员，它属于整个类，而不是类的每个实例。静态成员在内存中只有一份拷贝，所有类的对象共享这个拷贝。这里我们将深入探讨静态成员的初始化，特别是针对整型和枚举型...
浅析C++的特殊工具与技术
09-05
在C++编程中，掌握特殊的工具和技术对于提升代码性能和编写高效程序至关重要。本文将深入浅析C++中的一些关键工具和技术，包括内存优化、运行时类型识别、类成员的指针以及嵌套类。 首先，内存优化是提高程序效率的...
C++系列③---静态成员（函数）与非静态成员（函数），常量函数，私有继承与公有继承
Elsa~的博客
09-15 756
文章目录： 一、静态成员与非静态成员的区别？ 二、静态成员函数与非静态成员函数的区别？ 三、C++中引入静态成员函数有什么意义？ 四、什么是常成员函数？ 五、C++中引入常成员函数有什么意义？ 六、C++中私有继承、公有继承的区别？ 一、静态成员与非静态成员的区别？ ①、名称上的区别 成员变量也叫实例变量；静态变量也叫类变量。 ②、内存存储的区别： 成员变量存储到堆内存的对象...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1195
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++ primer plus 第16章string 类和标准模板库, 关联容器
zhyjhacker的博客
07-25 662
C++ primer plus 第16章string 类和标准模板库, 关联容器。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 273
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1133
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
＜＜C++ Primer Plus（第6版）＞＞12.1 动态内存和类：知识记录
gsp1004的博客
07-25 848
虽然原书中提到用等号来初始化值可能会导致调用赋值运算符(多执行赋值的步骤，效率低)，但是我实测并没有此问题。当然，这个结果是符合预期的，毕竟明明是没必要去多执行一次赋值运算符来赋值的。但是不排除别的环境，别的VS版本，甚至在别的优化等级下表现不同。所以建议自行测试。即便如此，还是建议初始化一个对象使用变量后面用括号赋值初始化的值的方式: StringBad ditto(motto);来规避可能的歧义和不确定的执行流程。默认的复制构造函数和默认的赋值运算符都是浅拷贝/浅复制。
C++(week14): C++提高:(一)面向对象设计：设计原则、设计模式
最新发布
Edward2022的博客
07-25 744
类与类之间的五种关系、面向对象的七种设计原则、23种设计模式
C++友元成员函数详解
友元成员函数是这个机制的一个特殊形式，它是一个类的成员函数，但同时也被声明为另一个类的友元。这意味着这个成员函数不仅能够访问它所在类的私有和公有成员，还能访问声明它为友元的那个类的私有和公有成员。这样...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值