【C++】学习笔记——内存管理

简介: 【C++】学习笔记——内存管理

二、类和对象

20. 友元

1. 友元函数

我们在实现日期类的时候也实现了重载 operator<<operator>> ,但是由于 this指针 位于形参的第一个位置,我们不得不将这个重载函数设成全局函数,但是全局函数又不能访问类的私有成员变量。我们是怎么解决这个问题的呢?是的,我们将这个函数的声明放在类内,然后在前面加上 friend 关键字,使其成为友元函数,友元函数就能够在类外访问类的私有成员变量了。

友元函数突破了封装,提供了便利,但这一定是好的吗?类的封装是非常重要的,友元函数能不使用就不使用。

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

友元函数不能用const修饰

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

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

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

2.友元类

友元不仅有友元函数,还有友元类。

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

在上面的时间类中,友元了一个日期类,这代表 时间类认为日期类是它的朋友,所以日期类可以任意访问时间类的成员函数和成员变量 。但是!假如日期类里面并没有将时间类声明成友元类的话,时间类则不能访问日期类的私有成员 。友元的关系是单向的,我是你的朋友并不代表你是我的朋友。

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

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

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

友元关系不能继承。

21. 内部类

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

class A
{
public:
  // 内部类
  class B
  {
  public:
    void foo(const A& a)
    {
      cout << k << endl;
      cout << a.h << endl;
    }
  };
private:
  static int k;
  int h;
};

其实内部类又有什么特殊的,只是 B 这个类受 类A 的类域的限制,必须先访问 类A 的域才能访问到 类B ,其次就是 内部类天生就是外部类的友元类 ,内部类能够访问到外部类的私有成员,外部类却访问不到内部类的私有成员。

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

22. 匿名对象

匿名对象就是没有名字的对象,生命周期只有一行 。这个对象一行内完成构造和析构。

#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;
};
int main()
{
  // 有名对象
  A aa1;
  A aa2(2);
  
  // 匿名对象
  A();
  A(3);
  return 0;
}

匿名对象的作用是什么呢?匿名作用适合用来传参,不需要取名字,消亡的快。但是有名函数通通可以做到😂。

class Solution {
public:
  int Sum_Solution(int n) {
    //...
    return n;
  }
};
int main()
{
  // 匿名对象的使用
  Solution().Sum_Solution(10);
  return 0;
}

23. 拷贝对象时的一些编译器优化

在传参和传返回值的过程中,一般编译器会做一些优化,减少对象的拷贝,这个在一些场景下还是非常有用的。每个编译器优化的程度不一样,所以这部分了解即可。

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

每个编译器优化程度不一样,结果不同也不要担心。

三、内存管理

1. C/C++内存分布

C++的内存分布和C语言保持一致。

其中数据段也叫做静态区,代码段也叫做常量区。

  1. 栈又叫堆栈–非静态局部变量/函数参数/返回值等等,栈是向下增长的。
  2. 内存映射段是高效的I/O映射方式,用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存,做进程间通信。
  3. 堆用于程序运行时动态内存分配,堆是可以上增长的。
  4. 数据段–存储全局数据和静态数据。
  5. 代码段–可执行的代码/只读常量。

2. C语言中动态内存管理方式:malloc/calloc/realloc/free

void Test ()
{
 int* p1 = (int*) malloc(sizeof(int));
 free(p1);
 
 // 1.malloc/calloc/realloc的区别是什么?
 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);
 
 // 2.这里需要free(p2)吗?
 free(p3);
}

1.malloc是分配内存,并不初始化内容;calloc是分配内存,但是将内容初始化为0;realloc是重新分配内存,可以在原本的内存上扩容,不初始化。

2.不需要,因为内存并没有增加,属于原地扩容,此时p3和p2指向同一片空间,释放一个即可。

3. C++内存管理方式

C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力,而且使用起来比较麻烦,因此C++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理

#include<iostream>
using namespace std;
int main()
{
  int* p1 = (int*)malloc(sizeof(int));
  
  // p2指向一个int大小的空间
  int* p2 = new int;
  // 指向10个int大小的空间
  int* p3 = new int[10];
  // 指向一个int大小的空间并且初始化为3
  int* p4 = new int(3);
  // 指向10个int大小的空间并把前5个初始化为。。。
  int* p5 = new int[10] { 1, 2, 3, 4, 5};
  free(p1);
  
  delete p2;
  delete[] p3;
  delete p4;
  delete[] p5;
  return 0;
}

在C语言中,mallocfree 俩个都是函数,而C++里, newdelete 则是两个关键字。new 非常好用,自动识别类型和个数,在用法上,new 更加简洁,且还可以控制初始化如果是自定义类型,new 则会开空间并且调用自定义类型的构造函数new 开空间失败了会抛异常,不需要手动检查

申请和释放单个元素的空间,使用 new 和 delete 操作符,申请和释放连续的空间,使用 new[] 和 delete[]。注意:需要匹配起来使用。

在申请自定义类型的空间时,new 会调用构造函数,delete 会调用析构函数,而 malloc 与 free 不会。

目录
相关文章
|
11天前
|
存储 C语言 C++
【C/C++】动态内存管理( C++:new,delete)
C++的`new`和`delete`用于动态内存管理,分配和释放内存。`new`分配内存并调用构造函数,`delete`释放内存并调用析构函数。`new[]`和`delete[]`分别用于数组分配和释放。不正确匹配可能导致内存泄漏。内置类型分配时不初始化,自定义类型则调用构造/析构。`operator new`和`operator delete`是系统底层的内存管理函数,封装了`malloc`和`free`。定位`new`允许在已分配内存上构造对象,常用于内存池。智能指针等现代C++特性能进一步帮助管理内存。
|
11天前
|
存储 编译器 程序员
【C/C++】动态内存管理(C:malloc,realloc,calloc,free)
探索C++与C语言的动态内存管理:从malloc到new/delete,了解内存分布及栈、堆的区别。文章涵盖malloc、realloc、calloc与free在C中的使用,强调内存泄漏的风险。C++引入new和delete,支持对象构造与析构,还包括operator new和placement-new。深入分析内存管理机制,揭示C与C++在内存处理上的异同。别忘了,正确释放内存至关重要!
|
13天前
|
算法 Java C++
C++和Python在内存管理上的主要区别是什么?
【7月更文挑战第2天】C++和Python在内存管理上的主要区别是什么?
11 1
|
5天前
|
安全 算法 编译器
C++一分钟之-内存模型与数据竞争
【7月更文挑战第10天】了解C++11内存模型对多线程编程至关重要。它定义了线程间同步规则,包括顺序一致性、原子操作和内存屏障。数据竞争可能导致不确定行为,如脏读和丢失更新。可通过互斥量、原子操作和无锁编程避免竞争。示例展示了`std::mutex`和`std::atomic`的使用。掌握内存模型规则,有效防止数据竞争,确保多线程安全和性能。
11 0
|
13天前
|
存储 Java 程序员
Python和C++在内存管理方面有什么不同?
【7月更文挑战第2天】Python和C++在内存管理方面有什么不同?
13 0
|
13天前
|
Java C++ 开发者
如何根据项目需求选择使用C++还是Python进行内存管理?
【7月更文挑战第2天】如何根据项目需求选择使用C++还是Python进行内存管理?
16 0
|
13天前
|
算法 Java C++
C++和Python在内存分配策略上的主要区别是什么?
【7月更文挑战第2天】C++和Python在内存分配策略上的主要区别是什么?
12 0
|
13天前
|
Java 程序员 C++
C++和Python在内存分配、释放以及垃圾回收机制上有何不同?
【7月更文挑战第2天】C++和Python在内存分配、释放以及垃圾回收机制上有何不同?
11 0
|
3天前
|
设计模式 安全 编译器
【C++11】特殊类设计
【C++11】特殊类设计
22 10
|
8天前
|
C++
C++友元函数和友元类的使用
C++中的友元(friend)是一种机制,允许类或函数访问其他类的私有成员,以实现数据共享或特殊功能。友元分为两类:类友元和函数友元。类友元允许一个类访问另一个类的私有数据,而函数友元是非成员函数,可以直接访问类的私有成员。虽然提供了便利,但友元破坏了封装性,应谨慎使用。
39 9