C++之类与对象(完结撒花篇)(下)

简介: C++之类与对象(完结撒花篇)(下)

C++之类与对象(完结撒花篇)(下):https://developer.aliyun.com/article/1624952


3.static成员

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

• 静态成员变量为 所有类对象所共享,不属于某个具体的对象,不存在对象中,存放在静态区。

• 用static修饰的成员函数,称之为静态成员函数,静态成员函数没有this指针。

• 静态成员函数中可以访问其他的静态成员,但是不能访问非静态的,因为没有this指针。

• 非静态的成员函数,可以访问任意的静态成员变量和静态成员函数。

• 突破类域就可以访问静态成员,可以通过类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数。

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

• 静态成员变量 不能在声明位置给缺省值初始化,因为缺省值是个构造函数初始化列表的,静态成员变量不属于某个对象,不走构造函数初始化列表。

#include <iostream>
using namespace std;
class A {
public:
  A() {
    ++_count;
  }
  A(const A& count) {
    ++_count;
 
  }
  ~A() {
    --_count;
  }
  static int getcount() {
    return _count;
  }
private:
  //类里面声明
  static int _count;
};
int A::_count = 520;
int main() {
  cout << A::getcount() << endl; // 输出:520
  A t1; // _count 增加到 521
  A t2(t1); // _count 增加到 522
  cout << A::getcount() << endl; // 输出:522
  // 此时 t1 和 t2 仍然存在
  cout << t1.getcount() << endl;//522
  cout << t2.getcount() << endl;//522
  {
    A t3(t1); // _count 增加到 523
    cout << A::getcount() << endl; // 输出:523
  } // t3 超出作用域, _count 减少到 522
  cout << A::getcount() << endl; // 输出:522
  return 0;
}

题目练习

设已经有A,B,C,D 4个类的定义,程序中A,B,C,D构造函数调⽤顺序为?(E)

设已经有A,B,C,D 4个类的定义,程序中A,B,C,D析构函数调⽤顺序为?(B)

C c;

int main() {

A a;

B b;

static D d;

return 0;

}

A:D B A C             B:B A D C            C:C D B A

D:A B D C             E:C A B D            F:C D A B

在全局或局部作用域中,构造函数的调用顺序如下:

  1. 全局和静态对象的构造:在程序启动时,全局对象(如果有)和静态对象会首先被构造。
  2. 局部对象的构造:然后,当程序进入 main() 函数时,局部对象的构造按定义顺序调用。

析构函数的调用顺序与构造函数的顺序相反。析构函数会在对象的生命周期结束时被调用,顺序如下:

  1. 局部对象的析构:当程序退出 main() 函数时,局部对象按定义的相反顺序析构。
  2. 全局和静态对象的析构:在 main() 函数结束后,全局对象和静态对象会被析构。

4. 友元

• 友元提供了一种突破类访问限定符封装的方式,友元分为: 友元函数和友元类,在函数声明或者类声明的前面 加friend,并且把友元声明放到一个类的里面。

• 外部友元函数可访问类的私有和保护成员,友元函数仅仅是一种声明,他不是类的成员函数。

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

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

友元类中的成员函数都可以是另一个类的友元函数,都可以访问另一个类中的私有和保护成员。

• 友元类的关系是单向的,不具有交换性,比如A类是B类的友元,但是B类不是A类的友元。

友元类关系不能传递,如果A是B的友元, B是C的友元,但是A不是B的友元。

• 有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。

#include <iostream>
using namespace std;
 
class B;//前置声明
class A {
  friend void func(const A& a, const B& b);
private:
  int _a = 520;
  int _b = 1314;
};
class B {
  friend void func(const A& a, const B& b);
private:
  int _a = 1314;
  int _b = 520;
};
void func(const A& a, const B& b) {
  cout << a._a << endl;
  cout << b._b << endl;
}
 
int main() {
  A a;
  B b;
  func(a, b);
  return 0;
}

#include<iostream>
using namespace std;
class A
{
  // 友元声明
  friend class B;
private:
  int _a1 = 520;
  int _a2 = 1314;
};
class B
{
public:
  void func1(const A& aa)
  {
    cout << aa._a1 << endl;
    cout << _b2 << endl;
  }
  void func2(const A& aa)
  {
    cout << aa._a2 << endl;
    cout << _b1 << endl;
  }
private:
  int _b1 = 520;
  int _b2 = 1314;
};
int main()
{
  A aa;
  B bb;
  bb.func1(aa);
  bb.func2(aa);
  return 0;
}

5.内部类

• 如果一个类定义在另一个类的内部,这个内部类就叫做内部类。内部类是一个独立的类,跟定义在全局相比,他只是受外部类类域限制和访问限定符限制,所以外部类定义的对象中不包含内部类。

内部类默认是外部类的友元类

• 内部类本质也是一种封装,当A类跟B类紧密关联,A类实现出来主要就是给B类使用,那么可以考虑把A类设计为B的内部类, 如果放到private/protected位置,那么A类就是B类的专属内部类,其他地方都用不了。

#include <iostream>
using namespace std;
 
class A {
private:
    static int _a; // 静态成员
    int _b;        // 非静态成员
public:
    class B {
    public:
        void print(const A& a) {
            cout << _a << endl;   // 访问静态成员
            cout << a._b << endl; // 访问非静态成员
        }
    };
};
 
int A::_a = 520; // 静态成员初始化
 
int main() {
    cout << "A类的大小:" << sizeof(A) << endl; // 输出 A 类的大小
    A::B b; // 创建 B 类的对象
    A aa;   // 创建 A 类的对象
    b.print(aa); // 调用 print 函数
    return 0;
}

6.匿名对象

用类型(实参) 定义出来的对象叫做匿名对象,相比之前我们定义的 类型 对象名(实参) 定义出来的 叫有名对象

匿名对象生命周期只在当前一行,一般临时定义一个对象当前用一下即可,就可以定义匿名对象。

#include <iostream>
using namespace std;
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;
  }
};
 
bool myfunction(int i, int j) { return (i > j); }
 
int main()
{
  A aa1;  //有名对象
 
  // 不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
  //A aa2();
 
  // 生命周期只在当前一行
  A(); // 匿名对象
  A(1);
 
  Solution st;
  cout << st.Sum_Solution(10) << endl;
 
  // 为了更方便
  cout << Solution().Sum_Solution(10) << endl;
  return 0;
}

7.对象拷贝时的编译器优化

• 现代编译器会为了尽可能提高程序的效率,在不影响正确性的情况下会尽可能减少一些传参和传参过程中可以省略的拷贝。

• 如何优化C++标准并没有严格规定,各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化,有些更新更"激进"的编译还会进行跨行跨表达式的合并优化。

#include <iostream>
using namespace std;
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;
    }
  void Print()
  {
    cout << "A::Print->" << _a << endl;
  }
 
  A& operator++()
  {
    _a += 100;
 
    return *this;
  }
private:
  int _a ;
};
void f1(A aa)
{}
A f2()
{
  A aa(1);
  ++aa;
  cout << "##########" << endl;
  return aa;
}
int main() {
  A aa1 ;
  aa1.Print();
  //const A& aa2 = 2;
  //A aa3(aa2);
  //A aa1;
  //f1(aa1);
  //cout << endl;
 
  // 隐式类型,连续构造+拷⻉构造->优化为直接构造
  //f1(1);
  // ⼀个表达式中,连续构造+拷⻉构造->优化为⼀个构造
  
  //f1(A(2));
  //cout << endl;
  //cout << "***********************************************" << endl;
  
  // 传值返回
  // 返回时⼀个表达式中,连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 (vs2019)
  // ⼀些编译器会优化得更厉害,进⾏跨⾏合并优化,直接变为构造。(vs2022)
  //f2();
  //cout << endl;
  // 返回时⼀个表达式中,连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 (vs2019)
  
     // ⼀些编译器会优化得更厉害,进⾏跨⾏合并优化,直接变为构造。(vs2022)
    // A aa2 = f2();
  // cout << endl;
  
     // ⼀个表达式中,连续拷⻉构造+赋值重载->⽆法优化
     aa1 = f2();
   cout << endl;
   A ret = f2();
    ret.Print();
    cout << "*********" << endl << endl;
   //
   return 0;
 
}

结束语

本节内容到此结束,类与对象的学习也暂时告别一段落了,希望接下来继续能和大家探讨C++的学习,最后呢,感谢各位友友的支持,讲解不足之处也希望大家多多包涵!!!

目录
相关文章
|
2月前
|
编译器 C++
C++之类与对象(完结撒花篇)(上)
C++之类与对象(完结撒花篇)(上)
37 0
|
24天前
|
存储 编译器 C++
【c++】类和对象(中)(构造函数、析构函数、拷贝构造、赋值重载)
本文深入探讨了C++类的默认成员函数,包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化,析构函数用于对象销毁时的资源清理,拷贝构造函数用于对象的拷贝,赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项,并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
56 4
|
26天前
|
存储 编译器 Linux
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
57 4
|
2月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象(下)
【C++打怪之路Lv5】-- 类和对象(下)
28 4
|
2月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象(中)
【C++打怪之路Lv4】-- 类和对象(中)
25 4
|
2月前
|
存储 编译器 C语言
【C++打怪之路Lv3】-- 类和对象(上)
【C++打怪之路Lv3】-- 类和对象(上)
17 0
|
2月前
|
编译器 C++
C++之类与对象(3)(下)
C++之类与对象(3)(下)
36 0
|
12天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色,它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作,帮助读者更好地理解和掌握`string`类的应用。
25 2
|
18天前
|
存储 编译器 C++
【c++】类和对象(下)(取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象)
本文介绍了C++中类和对象的高级特性,包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项,帮助读者深入了解C++面向对象编程的核心机制。
53 5
|
2月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
23 1