【C++初阶】——初始化列表&static成员&友元&内部类&匿名对象

简介: 前几篇文章我们对于分别对C++类和对象进行了一系列的探讨,包括类和对象的认识、类中的6个默认成员函数。在成员函数中我们学习了构造函数,但是构造函数还有一些问题需要我们继续深入的学习,让我们开始今天的学习吧!!!

再谈构造函数

在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。

class Date
{
public:
Date(int year, int month, int day)
{
//赋值并非初始化
  _year = year;
  _month = month;
  _day = day;
}
private:
int _year;
int _month;
int _day;
};

虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象中成员变量
的初始化,构造函数体中的语句只能将其称为赋初值而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值。


初始化列表

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

 

class Date
{
public:
Date(int year, int month, int day) 
    //定义,初始化
  : _year(year)
  , _month(month)
  , _day(day)
{}
private:
//成员的声明
int _year;
int _month;
int _day;
};

 

注意

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员,必须放在初始化列表位置进行初始化:

 

·              引用成员变量

·              const成员变量

·              自定义类型成员变量(且类中没有构造函数时)

class A
{
public:
  A(int t)
    :_t(t)
  {
  }
private:
  int _t;
};
class Date
{
public:
  Date(int year, int month, int day, int i, int& refn)
    //初始化列表
    :_year(year)
    , _month(month)
    , _i(i)
    , _n(refn)
    ,_a(0)
  {
    _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
  const int _i;
  int& _n;
  A _a;
};
int main()
{
  int n = 30;
  int t = 10;
  Date d1(2023, 11, 1, 9, n);
  return 0;
}

3.尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,
一定会先使用初始化列表初始化。

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

看看下面这道题

 

class A
{
public:
  A(int a)
   :_a1(a)
   ,_a2(_a1)
 {}
  void Print() {
    cout<<_a1<<" "<<_a2<<endl;
 }
private:
  int _a2;
  int _a1;
};
int main() {
  A aa(1);
  aa.Print();
}

答案为 1  随机值

根据上面的点,先用_a1初始化_a2_a1为随机值所以_a2为随机值;在使用a初始化_a1,所以_a1a的值即1


explicit关键字

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

explicit 关键字
class A
{
public:
  A(int a)
    :_a(a)
  {
  }
private:
  int _a;
};
int main()
{
  A aa(2023);
//含有隐式类型转化,将2隐式转化为一个临时的类A常量,2不变
  aa = 2;
//去掉const编译器会报错
    const A& _aa=2;
  return 0;
}

427097f2d81148a9b8ee42d8543b588d.png


添加explicit关键字会阻止这种隐式类型转化

 

class A
{
public:
  explicit A(int a)
    :_a(a)
  {
  }
private:
  int _a;
};
int main()
{
  A aa(2023);
  aa = 2;
  const A& _aa = 2;
  return 0;
}

17af9966177e45a6a23bf780f691ca69.png

匿名对象

特点:不用起名字,生命周期只有这一行

class A
{
public :
  void Print()
  {
  }
  ~A()
  {
    cout << "~A()调用" << endl;
  }
private:
  int _a=1;
};
int main()
{
  A().Print();
  return 0;
}

58a47ab6b0694e82902c5f9853f39a79.png

static成员

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

 面试题:实现一个类,计算程序中创建了多少个类的对象和通过调试还剩多少个类的对象;

类里定义两个变量肯定时不行的,没创建一个新类就会重新创建类里的成员。

第一种:使用全局变量在构造、拷贝构造和析构函数中分别求解;

第二种:使用静态成员实现

我们显然使用第二种来实现。

 

class A
{
public:
  A()
  {
    n++;
    m++;
  }
  A(const A& t)
  {
    n++;
    m++;
  }
  ~A()
  {
    --m;
  }
  //没有this指针
    //static修饰后可以使用域作用限定符直接访问类里的函数
  static void Print()
  {
    cout << n << " " << m << endl;
  }
private:
  static int n;
  static int m;
};
//类外面初始化
int A::m = 0;
int A::n = 0;
int main()
{
  A aa;
  A aaa;
  A::Print();
    //创建对象访问
  aa.Print();
  A();
    //直接访问
  A::Print();
  return 0;
}

ced0502a0b9447e4ac23654531764fb1.png


注意: 

1. 静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区
2. 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
5. 静态成员也是类的成员,受public、protected、private 访问限定符的限制


友元

友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以
友元不宜多用。
友元分为:友元函数和友元类

友元函数

class A
{
public:
  A(int x, int y) :_x(x) {}
//类里定义函数 前加关键字friend
  friend int sum(const A& a, const A& b);
private:
  int _x;
};
//类外面实现
int sum(const A& a, const A& b)
{
//访问类里的私有数据
  int sum = a._x + b._x;
  return sum;
}


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

说明:

1.    友元函数可访问类的私有和保护成员,但不是类的成员函数

2.    友元函数不能用const修饰

3.    友元函数可以在类定义的任何地方声明,不受类访问限定符限制

4.    一个函数可以是多个类的友元函数

5.    友元函数的调用与普通函数的调用原理相同

友元类

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

·       关系是单向的,不具有交换性。

比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。

·       友元关系不能传递                                                                                                                          

如果C是B的友元, B是A的友元,则不能说明C时A的友元。

·       友元关系不能继承,在继承位置再给大家详细介绍。

 

class Time
{
 friend class Date;  // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类
中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
   : _year(year)
   , _month(month)
   , _day(day)
 {}
 void SetTimeOfDate(int hour, int minute, int second)
 {
   // 直接访问时间类私有的成员变量
   _t._hour = hour;
   _t._minute = minute;
   _t._second = second;
 }
private:
 int _year;
 int _month;
 int _day;
 Time _t;
};

内部类

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

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

特性:

1. 内部类可以定义在外部类的publicprotectedprivate都是可以的。2. 注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。3. sizeof(外部类)=外部类,和内部类没有任何关系。

 

class A
{
public:
  class B
  {
//相当于写了 friend class A;
  public:
    void set( A& t)
    {    
            //访问A类的私有数据
      t._a = 1;
    }
  private:
    int _b;
  };
private:
  int _a;
};
int main()
{
  return 0;
}

再次理解类和对象

现实生活中的实体计算机并不认识,计算机只认识二进制格式的数据。如果想要让计算机认识现
实生活中的实体,用户必须通过某种面向对象的语言,对实体进行描述,然后通过编写程序,创
建对象后计算机才可以认识。比如想要让计算机认识洗衣机,就需要:

1. 用户先要对现实中洗衣机实体进行抽象---即在人为思想层面对洗衣机进行认识,洗衣机有什
么属性,有那些功能,即对洗衣机进行抽象认知的一个过程2. 经过1之后,在人的头脑中已经对洗衣机有了一个清醒的认识,只不过此时计算机还不清
楚,想要让计算机识别人想象中的洗衣机,就需要人通过某种面相对象的语言(比如:C++JavaPython)将洗衣机用类来进行描述,并输入到计算机中3. 经过2之后,在计算机中就有了一个洗衣机类,但是洗衣机类只是站在计算机的角度对洗衣
机对象进行描述的,通过洗衣机类,可以实例化出一个个具体的洗衣机对象,此时计算机才
能洗衣机是什么东西。4. 用户就可以借助计算机中洗衣机对象,来模拟现实中的洗衣机实体了。
在类和对象阶段,大家一定要体会到,类是对某一类实体(对象)来进行描述的,描述该对象具有那
些属性,那些方法,描述完成后就形成了一种新的自定义类型,才用该自定义类型就可以实例化
具体的对象。

 


 768c000997c64b12b93c040e5dd3a5af.png

相关文章
|
5天前
|
编译器 C语言 C++
类和对象的简述(c++篇)
类和对象的简述(c++篇)
|
2天前
|
编译器 C++ 开发者
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
|
2天前
|
安全 编译器 C语言
【C++篇】深度解析类与对象(中)
在上一篇博客中,我们学习了C++类与对象的基础内容。这一次,我们将深入探讨C++类的关键特性,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载、以及取地址运算符的重载。这些内容是理解面向对象编程的关键,也帮助我们更好地掌握C++内存管理的细节和编码的高级技巧。
|
2天前
|
存储 程序员 C语言
【C++篇】深度解析类与对象(上)
在C++中,类和对象是面向对象编程的基础组成部分。通过类,程序员可以对现实世界的实体进行模拟和抽象。类的基本概念包括成员变量、成员函数、访问控制等。本篇博客将介绍C++类与对象的基础知识,为后续学习打下良好的基础。
|
1月前
|
C++ 芯片
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
70 19
|
1月前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类(头歌实践教学平台习题)【合集】
声明一个CPU类,包含等级(rank)、频率(frequency)、电压(voltage)等属性,以及两个公有成员函数run、stop。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中,类是创建对象的蓝图。类的声明定义了类的成员,包括数据成员(变量)和成员函数(方法)。一个简单的类声明示例如下: classMyClass{ public: int
53 13
|
1月前
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用(头歌实践教学平台习题)【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括: 1. **类的继承关系基础概念**:介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**:详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**:解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类,添加特定属性并测试这些类的功能。最终通过创建教师和助教实例,验证代码
56 5
|
1月前
|
存储 算法 搜索推荐
【C++面向对象——群体类和群体数据的组织】实现含排序功能的数组类(头歌实践教学平台习题)【合集】
1. **相关排序和查找算法的原理**:介绍直接插入排序、直接选择排序、冒泡排序和顺序查找的基本原理及其实现代码。 2. **C++ 类与成员函数的定义**:讲解如何定义`Array`类,包括类的声明和实现,以及成员函数的定义与调用。 3. **数组作为类的成员变量的处理**:探讨内存管理和正确访问数组元素的方法,确保在类中正确使用动态分配的数组。 4. **函数参数传递与返回值处理**:解释排序和查找函数的参数传递方式及返回值处理,确保函数功能正确实现。 通过掌握这些知识,可以顺利地将排序和查找算法封装到`Array`类中,并进行测试验证。编程要求是在右侧编辑器补充代码以实现三种排序算法
43 5
|
1月前
|
Serverless 编译器 C++
【C++面向对象——类的多态性与虚函数】计算图像面积(头歌实践教学平台习题)【合集】
本任务要求设计一个矩形类、圆形类和图形基类,计算并输出相应图形面积。相关知识点包括纯虚函数和抽象类的使用。 **目录:** - 任务描述 - 相关知识 - 纯虚函数 - 特点 - 使用场景 - 作用 - 注意事项 - 相关概念对比 - 抽象类的使用 - 定义与概念 - 使用场景 - 编程要求 - 测试说明 - 通关代码 - 测试结果 **任务概述:** 1. **图形基类(Shape)**:包含纯虚函数 `void PrintArea()`。 2. **矩形类(Rectangle)**:继承 Shape 类,重写 `Print
49 4
|
1月前
|
设计模式 IDE 编译器
【C++面向对象——类的多态性与虚函数】编写教学游戏:认识动物(头歌实践教学平台习题)【合集】
本项目旨在通过C++编程实现一个教学游戏,帮助小朋友认识动物。程序设计了一个动物园场景,包含Dog、Bird和Frog三种动物。每个动物都有move和shout行为,用于展示其特征。游戏随机挑选10个动物,前5个供学习,后5个用于测试。使用虚函数和多态实现不同动物的行为,确保代码灵活扩展。此外,通过typeid获取对象类型,并利用strstr辅助判断类型。相关头文件如&lt;string&gt;、&lt;cstdlib&gt;等确保程序正常运行。最终,根据小朋友的回答计算得分,提供互动学习体验。 - **任务描述**:编写教学游戏,随机挑选10个动物进行展示与测试。 - **类设计**:基类
36 3