【C++】类和对象(下)

简介: 【C++】类和对象(下)

初始化列表

在对类和对象有了基本的认识之后,可以知道在创建对象的时候,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。

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;
};
int main(void)
{
  Date d(2000,1,1);//对象的整体定义
  return 0;
}

成员变量在类里面是声明,在主函数(main)中会对成员变量进行对象的整体定义,所有C++中规定了初始化列表,对象的成员定义的位置便是在初始化列表,在构造函数体内进行的是成员变量的赋值。

【注意】

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

成员变量可以在初始化列表不出现,但是出现最多只能出现一次,否则就会报错。

如果成员变量在初始化列表中不出现,成员变量中的内置类型不做处理,而自定义类型会调用其默认的构造函数。

2.类中包含以下成员,必须放在初始化列表位置进行初始化。

  • 引用成员变量
class B
{
public:
  B(int& i)
    :_i(i)
  {}
private:
  int& _i;
};
int main(void)
{
  int i = 10;
  B b1(i);
  return 0;
}

当类中存在引用成员变量时,必须在定义的时候初始化。

而在传引用值时,需要预先在出函数中定义好一个变量,构造函数接收参数时使用引用,如果只是传递一个值,在调用构造函数时会建立一个临时变量存储这个值,当构造函数销毁时,临时变量也会销毁,那么此时这个引用就会变成一种野引用。

  • const成员变量
class B
{
public:
  B(int c)
    :_c(c)
  {}
private:
  const int _c;
};
int main(void)
{
  B bb1(10);
  return 0;
}

当类中存在const修饰成员变量时,必须在定义的时候初始化。

被const修饰的变量只有一次初始机会,此后不可以被修改,所有必须在初始化列表的定义。

  • 自定义类型(且该类型没有默认的构造函数)
class A
{
public:
  A(int a)
    :_a(a)
  {}
private:
  int _a;
};
class B
{
public:
  B(int aa)
    :_aa(aa)
  {}
private:
  A _aa;
};
int main(void)
{
  B bb(1);
  return 0;
}

当自定义类型没有默认构造函数(全缺省、无参、编译器自定生成),需要在初始化列表定义,由默认构造函数,也可以在初始化列表进行定义。

有默认构造函数,默认构造函数的参数为缺省值,需要先考虑初始化列表,初始化列表可以看作是成员变量定义的地方。

【注意】

初始化只是构造函数的一部分,构造函数里面初始化赋值有俩种:第一种是在函数体内赋值,另一种是初始化列表定义。

也就是说,并不是初始化列表可以满足构造函数的问题,在构造函数内部可以进行一些其他的工作,例如内存的开辟,内存开辟后的判断,多维数组的建立等等。

class Stack
{
public:
  Stack(int capacity)
    :_capacity(capacity)
    ,_size(0)
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (_a == nullptr)
    {
      perror("malloc fail");
      return;
    }
  }
private:
  int* _a;
  int _capacity;
  int _size;
};

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

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

class A
{
public:
  A(int a)
    :_a2(a)
    ,_a1(_a2)
  {}
private:
  int _a1;
  int _a2;
};

这段错误代码就演示了在初始化列表中先定义_a1时,使用_a2的值赋给_a1,由于_a2还未定义,所以_a1会出现随机值。

构造时的类型转化

class A
{
public:
  A(int a)
    :_a(a)
  {}
private:
  int _a;
};
int main(void)
{
  A aa1 = 2;
  return 0;
}

对对象初始化时,将一个整数类型赋值给自定义类型,这种方式被称为隐式类型转换,会先通过整数构造一个自定义类型的临时变量,临时变量在拷贝构造给需要构造的对象——>这种过程直接会被编译器有优化为直接构造,不通过拷贝构造。

在同一个表达式中,连续的构造编译器一般会优化。

这段代码报错的原因是,整数int类型在构造一个自定义类型的临时变量时,由于临时变量具有常性,所以在将临时变量拷贝给自定义类型时,临时变量会释放,引用会变成野引用,所以直接使用引用是不可以的。

可以使用const来使用引用,因为const引用不能被修改。

  • 使用explicit关键字修饰构造函数,将会禁止构造函数的隐式住转化。

static成员

概念

声明为static的类成员称为类的静态成员,用static修饰的成员变量称为静态成员变量。用static修饰的成员函数称之为静态成员函数。

  • 静态成员变量一定要在类外进行初始化。

例如:检查程序中有多少个对象正在使用

//使用全局变量
int _count = 0;
class A
{
public:
  A(int a)
    :_a(a)
  {
    ++_count;
  }
  A(const A& a)
  {
    ++_count;
  }
  ~A()
  {
    --_count;
  }
private:
  int _a;
};
void Fun1()
{
  A aa3(2);
  cout << __LINE__ << ":" << _count << endl;
}
int main(void)
{
  A aa1(1);
  cout << __LINE__ << ":" << _count << endl;
  A aa2(aa1);
  cout << __LINE__ << ":" << _count << endl;
  Fun1();
  cout << __LINE__ << ":" << _count << endl;
  return 0;
}

此代码使用全局变量来测试,但是全局变量的劣势是任何地方都可以将其修改。

类中除了可以定义成员变量,同时也可以定义静态成员变量。

class A
{
public:
  A(int a)
    :_a(a)
  {
    ++_count;
  }
  A(const A& a)
  {
    ++_count;
  }
  ~A()
  {
    --_count;
  }
  static int GetCount()
  {
    return _count;
  }
private:
  int _a;
  static int _count;
};
int A::_count = 0;
void Fun1()
{
  A aa3(2);
  cout << __LINE__ << ":" << A::GetCount() << endl;
}
int main(void)
{
  A aa1(1);
  cout << __LINE__ << ":" << A::GetCount() << endl;
  A aa2(aa1);
  cout << __LINE__ << ":" << A::GetCount() << endl;
  Fun1();
  cout << __LINE__ << ":" << A::GetCount() << endl;
  return 0;
}

对于成员变量与静态成员变量的区别是,成员变量属于每一个类对象,每一个对象中都会有成员变量,而静态成员变量只属于类,属于类中每一个类对象共享的变量,存储在静态区,其声明周期是全局的。

静态成员变量只在全局位置,类的外面定义,由于静态成员变量在类中被封装后变成私有,所以静态成员函数不可以被访问,所以可以使用类中公共的成员函数。

class A
{
public:
  A(int a)
    :_a(a)
  {
    ++_count;
  }
  A(const A& a)
  {
    ++_count;
  }
  ~A()
  {
    --_count;
  }
  int GetCount()
  {
    return _count;
  }
private:
  int _a;
  static int _count;
};
int A::_count = 0;
void Fun1()
{
  A aa3(2);
  cout << __LINE__ << ":" << aa3.GetCount() << endl;
}
int main(void)
{
  A aa1(1);
  cout << __LINE__ << ":" << aa1.GetCount() << endl;
  A aa2(aa1);
  cout << __LINE__ << ":" << aa1.GetCount() << endl;
  Fun1();
  cout << __LINE__ << ":" << aa1.GetCount() << endl;
  return 0;
}

这种方式是无法对没有对象的程序进行调用函数。

所以也可以使用静态成员函数,静态成员函数没有this指针,指定类域或者访问限定符就可以访问静态成员函数,静态成员函数中不能使用非静态成员变量,因为没有this指针。

【注意】由于静态成员变量无法进入构造,所以无法通过初始化列表定义,所以在声明静态成员变量时,无法给缺省值。

class Sum
{
public:
    Sum()
    {
        _sum += _num;
        ++_num;
    }
    static int GetSum()
    {
        return _sum;
    }
private:
    static int _num;
    static int _sum;
};
int Sum::_num = 1;
int Sum::_sum = 0;
class Solution {
public:
    int Sum_Solution(int n) 
    {
        Sum arr[n];   
        return Sum::GetSum();
    }
};
  • 设计一个类只能在栈上创建对象
class A
{
public:
  static A GetStackObj(int a)
  {
    A a1(a);
    return a1;
  }
private:
  A(int a1)
    :_a1(a1)
  {}
  int _a1;
};
int main(void)
{
  A a1 = A::GetStackObj();
  return 0;
}

特性

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

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

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

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

5.静态成员也是类的成员,受public,protected,privated的影响

6.非静态成员函数可以调用静态成员函数,原因是静态成员函数没有this指针,不构成影响

7.静态成员函数不能调用非静态成员函数,是因为非静态成员函数调用需要this指针,而静态成员函数没有this指针

友元

友元提供了一种突破封装的方式,有时可以利用友元提供方便,但使用友元会增加耦合度(关联度更加紧密),可能会破坏封装。

友元使用关键字friend

友元可以分为:友元函数友元类

友元函数

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

以流插入举例:

class Date
{
  friend ostream& operator<<(ostream& out, Date& d);
public:
  Date(int year, int month, int day)
    :_year(year)
    ,_month(month)
    ,_day(day)
  {}
private:
  int _year;
  int _month;
  int _day;
};
ostream& operator<<(ostream& out, Date& d)
{
  out << d._year << "/" << d._month << "/" << d._day;
  return out;
}

观察这段代码,无法将operator<<放在类中成为重载成员函数,是因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置,this指针默认是第一个参数,也就是左操作数。

d << cout;

但是实际使用中cout需要是第一个形参对象,才能正常使用,可以将operator重载成全局函数,但是此时又会导致类外没办法访问成员,此时就需要友元来解决。

【注意】

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

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

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

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

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

友元类

class Date
{
  friend class Time;
public:
  Date(int year = 2000, int month = 1, int day = 1)
    :_year(year)
    , _month(month)
    , _day(day)
  {}
private:
  int _year;
  int _month;
  int _day;
};
class Time
{
public:
  Time(int hour, int minute, int second)
    :_hour(hour)
    ,_minute(minute)
    ,_second(second)
  {}
  void Print()
  {
    cout << _d._year << " " << _d._month << " " << _d._day << " "
       << _hour    << " " << _minute   << " " << _second;
  }
private:
  int _hour;
  int _minute;
  int _second;
  Date _d;
};
int main(void)
{
  Time T1(2, 23, 15);
  T1.Print();
  return 0;
}

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

  • 友元函数是单向的,不具有交换性。
  • 友元关系不能传递。
    例如:如果C是B的友元,B是A的友元,则不能说明C是A的友元。
  • 友元关系不能继承。

内部类

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

【特性】

1.内部类可以定义在外部类的public、protected、private都是可以的,其效果不同。

2.注意内部类可以直接访问外部类中的static成员,不需要外部类的对象或者类名

3.sizeof(外部类)==外部类,和内部类没有任何关系。

4.sizeof(类)时,里面的静态变量不计算,是因为静态变量没有存储在对象里面。

5.内部类天生是外部类的友元。

class A
{
public:
  class B
  {
  public:
    B()
      :_b(2)
    {}
    void Print(const A& a)
    {
      cout << a._a << _b << endl;
    }
  private:
    int _b;
  };
  A()
    :_a(1)
  {}
private:
  int _a;
};
int main()
{
  A a;
  A::B b;
  b.Print(a);
  return 0;
}

【注意】

内部类就是外部类的友元类,同友元类一样,内部类可以通过外部类的对象参数来访问外部类中的所有成员,但外部类不是内部类的友元。

匿名对象

  • 有名对象
A aa1(1);
  • 匿名对象
A(2);
  • 有名对象调用调用函数
Date d1;
  d1.Print();
  • 匿名函数调用对象
Date().Print();

有名对象的生命周期在当前函数局部域,匿名对象的生命周期在当前行。

匿名对象与有名对象的区别仅仅是匿名无名,而有名有名。

  • 匿名对象与临时对象相似,具有常性。
//错误代码
  A& a1 = A(1);
  //正确代码
  const A& a2 = A(1);

const引用延长了匿名对象的生命周期,生命周期在当前函数局部域。

同时,同一行一个表达式中连续的构造+拷贝构造会进行优化。

总结

在类和对象阶段,需要体会到,类是对某一类实体(对象)来进行描述的,描述该对象具有哪些属性,哪些方法,描述完成后就形成了一种新的自定义类型,才有该自定义类型就可以实例化具体的对象。


目录
打赏
0
1
1
0
6
分享
相关文章
|
1月前
|
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
68 19
【C++面向对象——类与对象】CPU类(头歌实践教学平台习题)【合集】
声明一个CPU类,包含等级(rank)、频率(frequency)、电压(voltage)等属性,以及两个公有成员函数run、stop。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中,类是创建对象的蓝图。类的声明定义了类的成员,包括数据成员(变量)和成员函数(方法)。一个简单的类声明示例如下: classMyClass{ public: int
50 13
【C++面向对象——继承与派生】派生类的应用(头歌实践教学平台习题)【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括: 1. **类的继承关系基础概念**:介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**:详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**:解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类,添加特定属性并测试这些类的功能。最终通过创建教师和助教实例,验证代码
49 5
【C++面向对象——群体类和群体数据的组织】实现含排序功能的数组类(头歌实践教学平台习题)【合集】
1. **相关排序和查找算法的原理**:介绍直接插入排序、直接选择排序、冒泡排序和顺序查找的基本原理及其实现代码。 2. **C++ 类与成员函数的定义**:讲解如何定义`Array`类,包括类的声明和实现,以及成员函数的定义与调用。 3. **数组作为类的成员变量的处理**:探讨内存管理和正确访问数组元素的方法,确保在类中正确使用动态分配的数组。 4. **函数参数传递与返回值处理**:解释排序和查找函数的参数传递方式及返回值处理,确保函数功能正确实现。 通过掌握这些知识,可以顺利地将排序和查找算法封装到`Array`类中,并进行测试验证。编程要求是在右侧编辑器补充代码以实现三种排序算法
38 5
【C++面向对象——类的多态性与虚函数】计算图像面积(头歌实践教学平台习题)【合集】
本任务要求设计一个矩形类、圆形类和图形基类,计算并输出相应图形面积。相关知识点包括纯虚函数和抽象类的使用。 **目录:** - 任务描述 - 相关知识 - 纯虚函数 - 特点 - 使用场景 - 作用 - 注意事项 - 相关概念对比 - 抽象类的使用 - 定义与概念 - 使用场景 - 编程要求 - 测试说明 - 通关代码 - 测试结果 **任务概述:** 1. **图形基类(Shape)**:包含纯虚函数 `void PrintArea()`。 2. **矩形类(Rectangle)**:继承 Shape 类,重写 `Print
47 4
【C++面向对象——类的多态性与虚函数】编写教学游戏:认识动物(头歌实践教学平台习题)【合集】
本项目旨在通过C++编程实现一个教学游戏,帮助小朋友认识动物。程序设计了一个动物园场景,包含Dog、Bird和Frog三种动物。每个动物都有move和shout行为,用于展示其特征。游戏随机挑选10个动物,前5个供学习,后5个用于测试。使用虚函数和多态实现不同动物的行为,确保代码灵活扩展。此外,通过typeid获取对象类型,并利用strstr辅助判断类型。相关头文件如&lt;string&gt;、&lt;cstdlib&gt;等确保程序正常运行。最终,根据小朋友的回答计算得分,提供互动学习体验。 - **任务描述**:编写教学游戏,随机挑选10个动物进行展示与测试。 - **类设计**:基类
32 3
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色,它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作,帮助读者更好地理解和掌握`string`类的应用。
89 2
【c++】类和对象(下)(取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象)
本文介绍了C++中类和对象的高级特性,包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项,帮助读者深入了解C++面向对象编程的核心机制。
155 5
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
163 4
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
240 4