C++：const，构造函数（补充），static，友元和内部类

最新推荐文章于 2026-01-28 17:05:11 发布
原创 最新推荐文章于 2026-01-28 17:05:11 发布 · 986 阅读 · 40 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

一丶const成员

       

1.const成员函数

       将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数 隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

#include<iostream>
using namespace std;
class Date {
public:
	Date(int year = 2024, int month = 2, int day = 14) :
		_year(year), _month(month), _day(day){}


	void RevisionDateYear() const // 实际上理解void RevisionDateYear(const Date *this) 
	{
		int year = 2023;
		this->_year = year;   //这里在编译过程就会出错
	}


private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d;
	d.RevisionDateYear();
	return 0;
}

2.取地址及const取地址操作符重载

class Date{ 
public:
    Date* operator&()
    {
        return this;
    }
    const Date* operator&()const
    {
        return this;
    }
private:
    int _year; 
    int _month; 
    int _day; 
};

       这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容。

二丶补充构造函数

1.初始化列表

        初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。每个成员只能初始化一次，并且  引用  成员变量，const  成员变量和 自定义类型成员(且该类没有默认构造函数时)

#include<iostream>
using namespace std;
class Time {
public:
	void PrintTime()
	{
		cout << _hour << ":" << _minute << ":" << _second << endl;
	}
	Time(int hour,int minute,int second)
		:_hour(hour),_minute(minute),_second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date {
public:
	Date(int month,int day,int hour = 8,int minute = 55,int second = 55)
		:_year(2024),_month(month),_day(day),_time(hour,minute,second)
	{}
	void PrintDate()
	{
		cout << _year << "-" << _month << "-" << _day << "-";
		_time.PrintTime();
	}
private:
	const int _year;     //const成员
	int &_month;          // 引用
	int _day;
	Time _time;           //没有默认构造函数的自定义类型
};
int main()
{
	Date d(2,19);            //缺省了，可以自己加上时分秒
	d.PrintDate();
	return 0;
}

       尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量， 一定会先使用初始化列表初始化。初始化时的顺序跟初始化列表的顺序没有关系，是按照成员声明的顺序来初始化的（比如上面就是按照priavte后面的顺序）。

2.explicit关键字

       构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

class Date
 {
 public:
// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
// explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
explicit Date(int year)
 :_year(year)
 {}
 /*
 // 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
有类型转换作用
// explicit修饰构造函数，禁止类型转换
explicit Date(int year, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 */
 Date& operator=(const Date& d)
 {
 if (this != &d)
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
 return *this;
 }
 private:
 int _year;
 int _month;
 int _day;
 };
 void Test()
 {
 Date d1(2022);
 // 用一个整形变量给日期类型对象赋值
// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
d1 = 2023;
 /*  将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转
换的作用  */
}

三丶static成员函数

1.概念

       声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用 static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

#include<iostream>
using namespace std;
class Date {
public:
	Date(int y,int m, int d)
		: _year(y),_month(m),_day(d)
	{}
	int GetMonthDay()
	{
		return MonthDay[_month];
	}
private:
	int _year;
	int _month;
	int _day;
	static int MonthDay[13];
};
int Date::MonthDay[13] = { 0,1,2,3,4,5,6,7,8,9,10,11,12 };  //数据乱写的,类外初始化
int main()
{
	Date d(2024,2,19);
	cout << d.GetMonthDay() << endl;
	return 0;
}

2.特性

(1). 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

(2). 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

(3). 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

(4). 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

(5). 静态成员也是类的成员，受public、protected、private 访问限定符的限制

四丶友元

1.友元函数

       在上一篇重载的内容已经提到过，现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成 全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

       友元，假设一个类是你的带锁的箱子，private类型的成员就是被锁住的东西，友元就是备份钥匙，这样友元函数也可以访问private类型了。声明时记得带上friend。

#include<iostream>
using namespace std;
class Date {
public:
	Date(int y,int m, int d)
		: _year(y),_month(m),_day(d)
	{}
	int GetMonthDay()
	{
		return MonthDay[_month];
	}
    friend ostream& operator<<(ostream& out,const Date d);
private:
	int _year;
	int _month;
	int _day;
	static int MonthDay[13];
};

ostream& operator<<(ostream & out,const Date d)
{
	out << d._year << ":" << d._month << ":" << d._day << endl;
	return out;
}

int Date::MonthDay[13] = { 0,1,2,3,4,5,6,7,8,9,10,11,12 };  //乱写的,类外初始化
int main()
{
	Date d1(2024,2,19);
	Date d2(2024,2,20);
    cout<<d1<<d2<<endl;
	return 0;
}

       在最开始已经解释了，疑惑的地方肯定是 函数内部return out ，这是为了能够连续输出（输入也是这样）。cout<<d1<<d2 == (operator<<(cout, d1)) << d2，就是cout和d1作为参数先调用了重载函数，返回out（实际上还是cout） 和 d2又调用了重载函数。

       友元函数可访问类的私有和保护成员，但不是类的成员函数。 友元函数不能用const修饰友元函数。可以在类定义的任何地方声明，不受类访问限定符限制。一个函数可以是多个类的友元函数 友元函数的调用与普通函数的调用原理相同  

2.友元类

       和友元函数类似，友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

（1）.友元类的关系时单向的，比如Date声明为Time 的友元类，Date可以访问Time，但是Time不能访问Date。

（2）.友元关系不能传递，A是B的友元类，B是C的友元类，但是A不是C的友元类

#include<iostream>
using namespace std;
class Time {
	friend class Date;
public:
	Time(int hour,int minute,int second)
		:_hour(hour),_minute(minute),_second(second)
	{}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date {
public:
	Date(int month ,int day,int hour = 10,int minute = 55,int second = 55)
		:_year(2024),_month(month),_day(day),_time(hour,minute,second)
	{}
	void PrintDate()
	{
		cout << _year << "-" << _month << "-" << _day << "-"
			 << _time._hour << "-" << _time._minute << "-" << _time._second;  
                        //可以直接访问，没有用友元函数                 
	}
private:
	const int _year;
	int &_month;
	int _day;
	Time _time;
};
int main()
{
	Date d(2,19);
	d.PrintDate();
	return 0;
}

五丶内部类

1.概念：

       如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类， 它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越 的访问权限。

2.注意：

       内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访 问外部类中的所有成员。但是外部类不是内部类的友元。

3.特性：

（1）. 内部类可以定义在外部类的public、protected、private都是可以的。

（2）. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。

（3）. sizeof(外部类)=外部类，和内部类没有任何关系

标签
#c++ #开发语言
bcyyyyyy
关注
[C++探索]初始化列表，static成员，友元函数，内部类，匿名对象
Anmory的博客
07-29 1348
我们共同进步本系列持续更新，关注我，带你了解更多C++知识下期再见。
【C++】const、static关键字和构造函数初始化
qq_64818885的博客
02-15 1961
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
C++基础——const成员函数
weixin_69283129的博客
11-11 1万+
C++ const成员函数
【C++】类的默认成员函数----const成员函数（超详细解析）
weixin_45031801的博客
11-01 1万+
详解C++中的const成员函数
C++ const的用法详解
热门推荐
Mi-ronin的博客
07-13 6万+
const在C/C++中是十分重要的，如果单纯理解为“常量”那么你的格局就小了，今天在这里给大家介绍一下const在C++中具体详细的用法。
C++const函数的运用：深度解析const函数的魅力
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
05-30 4927
C++const函数的运用：深度解析const函数的魅力
C++——const详解
kk阿彬
07-06 3万+
指针常量(顶层const)： 本质是一个常量的指针，指针指向的地址不能改变，该地址存储的数据可以改变。常量指针(底层const)： 指向常量的指针，，a是一个常量，p指向a的地址空间，a的值不能变，p的指向可以改变。更一般的，顶层const可以表示任意的对象是常量，对任何数据类型都适用，比如int、类、指针。 比较特殊的是：指针既可以是顶层const也可以是底层const，和其他类型有明显区别；const修饰变量主要有两个作用： 1、将变量定义为常量，保护被修饰的东西，防止意外的修改，增强程序的健壮性。co
类和对象——【const成员】【static成员】【友元】【内部类】
2401_82669797的博客
07-11 1853
本文讲述了：类和对象——【const成员】【static成员】【友元】【内部类】
C++ 类和对象（三）：构造函数补充、匿名对象、友元、内部类、类的static与const
凌桓丶的博客
04-25 1151
构造函数补充 匿名对象 友元 内部类 类的static与const 构造函数补充 列表初始化 讲列表初始化之前，要先讨论一下构造函数里面的语句到底是不是初始化 例子还是上次的日期类 class Date { public: Date(int year, int month, int day) { _year = year; _month = month; _day = d...
C++奇迹之旅：类和对象const成员&&static关键字&&友元&&内部类
a_sen的博客
04-29 1921
成员函数是指在类中被声明为 的成员函数 将修饰的“成员函数”称之为成员函数，修饰类成员函数，实际修饰该成员函数隐含的指针，表明在该成员函数中不能对类的任何成员进行修改。 我们来看看下面的代码 请思考下面的几个问题：小结： 关键字的使用只会导致权限的放小,不会导致权限的放大。 对成员变量只读时，建议加上关键字，需要修改成员变量，不能加指针这两个默认成员函数一般不用重新定义 ，编译器默认会生成。 这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指
【C++】const和static的用法
2402_88461821的博客
09-17 1498
本文介绍了C++中const与static关键字的用法及其结合应用。const主要用于限制变量/对象的可修改性，包括修饰普通变量、指针、函数参数/返回值、类成员和对象等场景。static则用于改变变量/函数的存储周期或作用域，包括修饰全局变量、局部变量以及类成员变量/函数。两者的结合应用主要体现在"类的静态常量"(static const)上，用于定义类级别的共享且不可修改的常量。文章通过具体代码示例详细说明了各种用法，帮助读者理解这两个关键字的正确使用方式。
C++ const 和static 区别
freedom62的博客
05-31 5237
const定义的常量在超出其作用域之后其空间会被释放。      在C++中，const成员变量也不能在类定义处初始化，只能通过构造函数初始化列表进行，并且必须有构造函数。       const数据成员 只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类的声明中初始化const数据成员，因为类的
C++中的 const和static 以及 static const 和const static
mhjie1998的博客
08-23 3201
对于C/C++语言来讲,const就是只读的意思,只在声明中使用;static一般有2个作用,规定作用域和存储方式.对于局部变量,static规定其为静态存储方式,每次调用的初始值为上一次调用的值,调用结束后存储空间不释放;对于全局变量,如果以文件划分作用域的话,此变量只在当前文件可见;对于static函数也是在当前模块内函数可见. const定义的常量在函数执行之后其空间会被释放，而static...
C++中const 、static、 static const和const static的初始化以及修改问题
bjyddxhfxq的博客
04-20 7113
转载自  http://blog.bccn.net/zpcdbc/categories/119746 一、const、static、static const、const static变量的初始化 Ⅰ.const的初始化 （1）只有这一种情况const变量可以不在声明的同时定义，那就是const变量作为类的数据成员出现时。例如： class Myclass { cons in
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
2301_80955819的博客
09-15 1822
今天我们学习了类和对象相关的新概念和知识，例如：取地址重载、static修饰成员、友元、内部类等，它们对于我们深入学习并理解c++的后续内容，以及实现对象的相关功能有很大帮助。
static, const, static const 与 const static
wenmin_shu的专栏
09-30 1万+
1. static const/ const static， 意义一样 namespace NdpiTransformersTest { class TestMain { public: ~TestMain(); static int run(int argc, const char** argv); private: static ConfigMgmtDataTypes::Co...
C++ const 与 static 详解：变量、函数、类成员的全面解析
保持分享欲
10-17 1208
C++中的const和static关键字是控制变量行为和存储方式的核心工具。const用于声明不可变性，可修饰变量、函数参数和成员函数，保证数据不被意外修改；static则控制存储期和链接性，使局部变量持久化、限制全局变量作用域，并实现类成员的共享。两者结合可定义类级别的编译期常量（static constexpr）。使用时需注意const成员函数不能修改状态、static成员需在类外定义等规则，遵循优先使用constexpr、参数用const&等最佳实践，以提升代码安全性和性能。
C++ 类和对象（五）：初始化列表、static、友元、内部类等7大知识点全攻略
最新发布
zhangzhangip的博客
01-28 1763
本文深入讲解了C++类和对象的核心概念，包括初始化列表、类型转换、static成员、友元关系和匿名对象等特性。重点分析了初始化列表的使用规则（必须初始化引用、const成员等）、类型转换的隐式规则（explicit禁止隐式转换）、static成员的共享特性（类外初始化）、友元关系的单向性等特点。
C++：const成员函数，初始化列表，static成员，友元
xiuwoaiailixiya的博客
09-13 1304
1.用static修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化。2.静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。3.用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。4.静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。5.非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值