C++------类与对象(下)

本文详细探讨了C++中的构造函数、初始化列表、static成员、友元、内部类和匿名对象的概念,以及拷贝对象时的编译器优化,强调了封装的重要性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

文章目录

  • 1. 再谈构造函数
  • 2. Static成员
  • 3. 友元
  • 4. 内部类
  • 5.匿名对象
  • 6.拷贝对象时的一些编译器优化
  • 7. 再次理解封装

提示:以下是本篇文章正文内容,下面案例可供参考

一、构造函数和初始化列表

初始化列表是用来初始化类的,虽然我们可以使用构造函数来初始化但是它和初始化列表不同

构造函数可以多次赋值,而初始化列表只能初始化一次。

(1)初始化列表

初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟 一个放在括号中的初始值或表达式。

class Date
{
public:
	Date( )//初始化列表
		  :_year(2022)
         ,_month(11)
          ,_day(11)
	{
		
		;
	}
Date( int year,int month,int day)//初始化列表,不想用默认值
		 :_year(year)
        ,_month(month)
        ,_day(day)
	{
		;
		
	}
	void print()const
	{

		cout << _year << "/" << _month << "/" << _day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d(11);
	d.print();

	return 0;
}

(2)初始化列表的初始化顺序

成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后 次序无关

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)//先初始化_a2,后初始化_a1
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();//    _a1输出1    _a2 随机值
}

(3)初始化列表初始化

在之前编译器自动生成的默认构造函数,它不会对内置类型初始化,C++对它打了个补丁,就是声明变量的时候可以给缺省值,这里的缺省值就是给初始化列表的默认值,当然如果初始化列表已经赋值,缺省值无效。

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员,必须放在初始化列表位置进行初始化: 引用成员变量 const成员变量 自定义类型成员(且该类没有默认构造函数时)

初始化列表可以解决构造函数解决不了引用和const变量,引用和const修饰的变量定义的时候必须给赋值。在用栈实现队列的时候,自定义类型调用它的默认构造函数,但是如果没有默认构造函数,已有的构造函数是需要传参的,就需要初始化列表

class A
{
public:
	A(int a)//不是默认构造函数,需要传参
		:_a(a)
	{}
private:
	int _a;
};
class B
{
public:
	B(int a, int ref)
		:_aobj(a)
		, _ref(ref)
		, _n(10)//初始化列表解决自定义类型初始化
	{}
private:
	A _aobj;  //自定义类型同时它没有默认构造函数
	int& _ref;  // 引用
	const int _n; // const
};

尽量使用初始化列表初始化,对于自定义成员的变量,初始化列表是最先执行的

(4)初始化列表和构造函数体的使用 

既然初始化列表可以解决大部分初始化问题,但是缺少检查,比如对于栈开空间需要检查是否开辟成功。我们可以用初始化列表初始化,函数体内检查。

Stack()
:*a((int*)malloc(sizeof(int)*3)
,top(0)
{

if(a==nullptr)
{
  
   return -1;
}


]

(5)explicit 关键字

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

class Date
{
public:
	
		// 1. 单参构造函数,没有使用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;
};
int main()
{
	Date d1(2022);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象,最后用无名对象给d1对象进行赋值
	d1 = 2023;
	return 0;
}

二.static关键字

(1)特性

static 修饰的变量和函数是这个类所共有的,所有该类的对象都可以访问它,可以理解为对象的全局函数和变量,也受限制符的限制。在类里面声明,在类外定义

1.修饰变量

它不属于对象,当是对象可以访问,也可以通过类域访问,当然它也受private等限制

2.修饰函数 

static修饰的函数,可以访问static变量,它没有隐藏的this指针,所以访问不了对象的成员。

不过既然是对象共享,对象是可以访问这个静态函数的

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

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

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

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

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

【问题】 1. 静态成员函数可以调用非静态成员函数吗?

                 不可以,没有this指针

                 2. 非静态成员函数可以调用类的静态成员函数吗?

                   可以

(2)访问static变量

1.通过类域

2.通过对象(static变量不存在对象里,但是编译器把它解释成到该对象的类域中寻找)

3.通过临时对象,临时对象生命周期只存在临时变量所在的这一行

class A
{
public:
A() { ++_scount; }
A(const A & t) { ++_scount; }
~A() { --_scount; }
static int GetACount() { return _scount; }//static 函数
private:
static int _scount;//static 变量在类中声明,类外定义属于这个类
};
int A::_scount = 0;//类外定义
void TestA()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
}


int main()
{    

	
	cout << A::GetACount() << endl;//通过域名
	A a;
	cout << a.GetACount() << endl;//通过对象
	cout << A().GetACount() << endl;//匿名对象,生命周期只在这一行
	


	return 0;
}

(3)调用静态函数

1.使用类域调用

2.对象调用/匿名对象

三,友元

(1).友元函数

友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在 类的内部声明,声明时需要加friend关键字。

/友元
class A {
public:
    A()
        :_a(1)
        ,_b(1)
    {

    }
    friend void print(A &d);//声明为友元函数,如果注释掉这行,print就访问不了_a,_b


private:
    int _a;
    int _b;
};
void print(A&d)
{
    cout <<d._a <<d._b << endl;
}
int main()
{
    A a;
    print(a);

    return 0;
}

(2)友元函数的特点

1.一个函数可以被多个类申明为友元函数

2.不是成员函数,不可以加const

3.在类里面申明,在类外面定义,没有隐藏的指针

2.友元类调用过程和普通函数相同

(2)友元类

//友元
class A {
friend class B;
private:
    int _a;
    int _b;
};


class B {
public:
    void print()//在B类中访问a的成员
    {
        _j = a._a;
    }
private:
    int _j;
    A a;
};
 

在类里面把一个类申明为友元类

特点:1.友元类可以访问类的protect和protect变量

          2. 关系是单向的,友元类可以访问类所有成员但是类却不可以访问友元类的私有成员

          3.友元关系不可以传递  A被B声明为友元类,B被C声明为友元类但是A不是C的友元类

          4.友元关系不可以通过继承传递

四.内部类

(1)概念

1.如果一个类定义在另一个类的内部,这个内部类就叫做内部类,它是一个独立的类。内部类是外部类的友元,它可以通过的对象参数访问外部类成员,外部类访问不了内部类的成员。

(2)特性

1.内部类可定义在private,public,private位置

2,sizeof()计算外部类,不包括内部类

3.内部类可以直接访问外部类的staic成员,不需要外部类的对象/类名。


//内部类
class A {
public:
	class B{
	public:
		void fun(A& a)
		{
			cout << a.h << endl;//通过对象参数访问成员
			cout << k << endl;//可直接访问静态成员
		}
	private:
		int a = 9;
	};
private:
	int h = 9;
	static int k;
};
int A::k = 5;

int main()
{
	A::B b;
	A a;
	b.fun(a);
	cout << sizeof(a);//a的大小只有h,k不包括b
	
	return 0;
}

 五.匿名对象

(1)匿名对象的用处

匿名对象有时候比较方便使用,要用到的地方直接匿名对象,不用创造对象然后在调用成员。不过

由于匿名对象的生命周期短,如果对象要周期生效,不使用匿名对象。


//匿名对象 A()

class A {
public:
	A(int k = 9)
		:_k(k)
	{

		cout << "A(int k=9)" << endl;
	
	}
	~A()
	{
		cout << "~A()";
	}
private:
	int _k;
};
int main()
{
	//匿名对象,只在这一行生效,过了这一行就会调用析构函数
	A();//// 我们可以这么定义匿名对象,匿名对象的特点不用取名字
	return 0;
}

六.拷贝对象时的一些优化

在传参和传返回值的过程中,一般编译器会做一些优化,减少对象的拷贝,这个在一些场景下还 是非常有用的。一般比较新的编译器都会优化

可以理解为编译器比较聪明,会对代码进行检查和判断。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}
	
		A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
void f1(A aa)
{}
A f2()
{
	A aa;
	return aa;
}
int main()
{
 // 传值传参
 A aa1;
 f1(aa1);
 cout << endl;
 // 传值返回
 f2();
 cout << endl;
 // 隐式类型,连续构造+拷贝构造->优化为直接构造
 f1(1);
 // 一个表达式中,连续构造+拷贝构造->优化为一个构造
 f1(A(2));
 cout << endl;
 // 一个表达式中,连续拷贝构造+拷贝构造->优化一个拷贝构造
 A aa2 = f2();
 cout << endl;
 // 一个表达式中,连续拷贝构造+赋值重载->无法优化
 aa1 = f2();
 cout << endl;
 return 0;
}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值