【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;
};

每个成员变量在初始化列表中只能出现一次,因为初始化只能初始化一次。

  如果存在引用成员变量、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 
};

 尽量使用初始化列表初始化,因为不管是否在初始化列表写,每个变量都会在初始化列表定义初始化。

class Time
{
public:
  Time(int hour = 0)
    :_hour(hour)
  {
    cout << "Time()" << endl;
  }
private:
  int _hour;
};
class Date
{
public:
  Date(int day)
  {}
private:
  int _day;
  Time _t;
};
int main()
{
  Date d(1);
  return 0;
}

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

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();
  return 0;
}


1f4af688f98340cf9e0b73c21e4420da.png

explicit关键字

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


class Date
{
public:
  // 单参构造函数,没有使用explicit修饰,具有类型转换作用
  // explicit修饰构造函数,禁止类型转换 -- explicit去掉之后,代码可以通过编译
  //explicit Date(int year)
  Date(int year)
    :_year(year)
  {}
  // 虽然有多个参数,但是创建对象时,后两个参数可以不传参,没有使用explicit修饰,具有类型转换作用
  // explicit修饰构造函数,禁止类型转换
  /*explicit Date(int year, int month = 1, int day = 1)
  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(2000);
  d1 = 2023;
  return 0;
}


61d9675413624bc2877a9dcd538693e4.png

ad66fa2dd6b444b5a168fc626661e041.png

static成员

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

class A
{
public:
  A()
  {
    ++_scount;
  }
  A(const A& t)
  {
    ++_scount;
  }
  ~A()
  {
    --_scount;
  }
  static int GetACount()
  {
    return _scount;
  }
private:
  static int _scount;
};
int A::_scount = 0;
void TestA()
{
  cout << A::GetACount() << endl;
  A a1, a2;
  A a3(a1);
  cout << A::GetACount() << endl;
}
int main()
{
  TestA();
  return 0;
}

83a6f1116b0f47b6b8dafbdb888c53a5.png

特性:

静态成员被所有类对象共享,不属于某一个具体的对象,存放在静态区中;

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

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

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

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

友元

  友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不能过多的使用。

友元函数

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

class Date
{
  friend ostream& operator<<(ostream& _cout, const Date& d);
  friend istream& operator>>(istream& _cin, Date& d);
public:
  Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
  {}
private:
  int _year;
  int _month;
  int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
  _cout << d._year << "-" << d._month << "-" << d._day;
  return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
  _cin >> d._year;
  _cin >> d._month;
  _cin >> d._day;
  return _cin;
}
int main()
{
  Date d;
  cin >> d;
  cout << d << endl;
  return 0;
}

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

  友元函数不能用const修饰;

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

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

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

友元类

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

  友元关系是单向的,不具有交换性;

  友元关系不能传递;

  友元关系不能继承。

class Time
{
  friend class Date;
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;
};

内部类

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

  内部类就是外部类的友元类,但是外部类不是内部类的友元。

特性

  内部类可以定义在外部类的任何访问限定符内(public、protected、private);

  内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名;

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

class A
{
private:
  static int k;
  int h;
public:
  class B
  {
  public:
    void foo(const A& a)
    {
      cout << k << endl;
      cout << a.h << endl;
    }
  };
};
class C
{
private:
  static int c;
  int h;
};
int A::k = 1;
int main()
{
  A a;
  A::B b;
  b.foo(A());
  C c;
  cout << sizeof(a) << endl;
  cout << sizeof(b) << endl;
  cout << sizeof(c) << endl;
  return 0;
}

匿名对象

  匿名对象的特点是没有名字,它的声明周期只在定义它那一行,是一次性的。

class A
{
public:
  A(int a = 0)
    :_a(a)
  {
    cout << "A(int a)" << endl;
  }
  ~A()
  {
    cout << "~A()" << endl;
  }
private:
  int _a;
};
class Solution {
public:
  int Sum_Solution(int n) 
  {
    return n;
  }
};
int main()
{
  A aa1;
  //A aa1();// 不能这么定义对象,因为编译器无法识别是一个函数声明,还是对象定义
  A();
  A aa2(2);
  Solution().Sum_Solution(10);
  return 0;
}
目录
相关文章
|
25天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色,它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作,帮助读者更好地理解和掌握`string`类的应用。
38 2
|
1月前
|
存储 编译器 C++
【c++】类和对象(下)(取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象)
本文介绍了C++中类和对象的高级特性,包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项,帮助读者深入了解C++面向对象编程的核心机制。
83 5
|
1月前
|
存储 编译器 C++
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
80 4
|
1月前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
88 4
|
2月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象(下)
【C++打怪之路Lv5】-- 类和对象(下)
31 4
|
2月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象(中)
【C++打怪之路Lv4】-- 类和对象(中)
32 4
|
2月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
26 1
|
2月前
|
存储 编译器 C语言
【C++打怪之路Lv3】-- 类和对象(上)
【C++打怪之路Lv3】-- 类和对象(上)
18 0
|
2月前
|
存储 编译器 C++
【C++类和对象(下)】——我与C++的不解之缘(五)
【C++类和对象(下)】——我与C++的不解之缘(五)
|
2月前
|
编译器 C++
【C++类和对象(中)】—— 我与C++的不解之缘(四)
【C++类和对象(中)】—— 我与C++的不解之缘(四)