C++ Primer Plus学习笔记12-类和动态内存分配

C++ 的 Rule-of-Three No More C++ 系列带你玩转各种现代 C++ 的重要知识,告诉你凡人也可以接触和拥抱 C++。 C++ 作为一个古老的面向对象编程语言,基本上大部分事情都是围绕着 class 展开。 引: 在介绍 rule-of-three 和 copy-and-swap idiom 之前,我们来回顾一下如何用 C++ 构造一个自定义类。 // Example 1 class Empty {}; E... 阅读详情

友元函数重载运算符的bug

1. 动态内存和类

C++使用new和delete运算符动态控制内存。在类中使用这些运算符将导致许多新的编程问题。这种情况下,析构函数必不可少。

构造函数必须分配足够的内存来存储数据,然后再将数据复制到内存中。析构函数需要包含delete语句删除成员指针指向的内存。
当使用一个对象初始化另一个对象时,编译器自动生成复制构造函数,这个构造函数不知道需要更新类中自定义的静态变量,因此会将类的设计方案搞乱。

1.1 特殊成员函数

C++自动提供以下成员函数:

  • 默认构造函数
  • 默认析构函数
  • 复制构造函数
  • 赋值运算符
  • 地址运算符

C++11提供了另外连个特殊成员函数:移动构造函数(move constructor)和移动赋值运算符(move assignment operator)。

1.1.1 默认构造函数

创建对象时总会调用构造函数。如果定义了构造函数,C++将不会定义默认构造函数。如果希望在创建对象时不显式地对它进行初始化,则必须显式地定义默认构造函数。

只要所有参数都有默认值,带参数的构造函数也是默认构造函数。但是一个类只能有一个默认构造函数。

1.1.2 复制构造函数

用于将一个对象复制到新构建的对象中。原型通常为:Class_name(const Class_name &);
它接受一个指向类对象的常量引用作为参数。

新建一个对象并将其初始化为同类现有对象时,复制构造函数将被调用。每当程序生成了对象副本,编译器都将使用复制构造函数;即,当函数按值传递对象或函数返回对象时,都将使用复制构造函数。

默认的复制构造函数逐个复制费静态成员(浅复制),复制的是成员的值。

1.1.3 赋值运算符

C++允许类对象赋值,是通过自动为类重载赋值运算符实现。原型为Class_name & Class_name::operator=(const Class_name &);
它接受并返回一个指向类对象的引用。
赋值运算符的隐式实现对成员进行逐个赋复制(浅复制)。

2. 在构造函数汇总使用new应注意的事项

  • 如果在构造函数中使用new初始化指针成员,则应在析构函数中使用delete。
  • new和delete必须相互兼容。
  • 如果有多个构造函数,则必须以相同的方式使用new(可以使用指针初始化为空,由于delete可以用于空指针)。因为只有一个析构函数。
  • 应定义一个复制构造函数,通过深度复制将一个对象初始化为另一个对象。
  • 应定义一个赋值运算符,通过深度复制将一个对象复制给另一个对象。

以前,空指针可以用0或NULL表示。C++传统上更喜欢用0,但是C++11提供关键字nullptr。

3. 有关返回对象的说明

3.1 返回指向const对象的引用

使用const引用的常见原因是为了提高效率。
如果函数返回传递给它的对象,可以通过返回引用来提高其效率。
首先,返回对象将调用复制构造函数,而返回引用不会。其次,引用指向的对象应该在调用函数执行时存在。第三,如果函数被声明为const引用,则返回对象的类型必须为const。

const Vector & Max(const Vector & v1, const Vector & v2){
  if (v1.magval() > v2.magval())
    return v1;
  else
    return v2;
}

3.2 返回指向非const对象的引用

3.3 返回对象

如果被返回的对象是被调用函数中的局部变量,则不应该采用引用的方式返回它。通常,被重载的算术运算符属于这一类。
在这种情况下,存在调用复制构造函数来创建被返回的对象的开销,这是无法避免的。

4. 使用指向对象的指针

// sayings2.cpp -- using pointers to objects
// compile with string1.cpp
#include <iostream>
#include <cstdlib> // for rand(), srand()
#include <ctime> // for time()
#include "string1.h"
const int ArSize = 10;
const int MaxLen = 81;
int main(){
  using namespace std;
  String name;
  cout << "Hi, what's your name?\n>> ";
  cin >> name;
  cout << name << ", please enter up to " <<ArSize
       << " short sayings <empty line to quit>:\n";
  String sayings[ArSize];
  char temp[MaxLen];  // temporary string storage
  int i;
  for(i = 0; i < ArSize; i++){
    cout << i + 1 << ": ";
    cin.get(temp, MaxLen);
    while(cin && cin.get()!='\n')
      continue;
    if(!cin || temp[0]=='\0') // empty line?
      break;
    else
      sayings[i] = temp;
  }
  int total = i;
  if (total > 0){
    cout << "Here are your sayings:\n";
    for(i = 0; i < total; i++)
      cout << sayings[i] << endl;
    // using pointers to keep track of shortest, first strings
    String * shortest = &sayings[0];
    String * first = &sayings[0];
    for(i = 1; i < total; i++){
      if (sayings[i].length() < shortest->length())
        shortest = &sayings[i]
      if (sayings[i] < *first)
        first = &sayings[i];
    }
    cout << "Shortest saying:\n" << *shortest << endl;
    cout << "First alphabetically:\n" << *first << endl;
    srand(time(0));
    int choice = rand() % total;
    // use new to create, initialize new String object
    String *favorite = new String(syaings[choice]);
    cout << "My favorite saying:\n" << *favorite << endl;
    delete favorite;
  }
  else
    cout << "Not much to say, eh?\n";
  cout << "Bye.\n";
  return 0;
}

String * favorite = new String(sayings[choice]);使用new为整个对象分配内存,即为保存字符串地址的str指针和·len成员分配内存。创建对象将调用构造函数,构造函数分配用于保存字符串的内存,并将字符串的地址赋给str。
当程序不需要该对象时,使用delete删除;这只释放用于保存str指针和len成员的空间,并不释放str指向的内存。释放str指向的内存由析构函数完成。

// placenew1.cpp -- new, placement new, no delete
#include <iostream>
#include <string>
#include <new>
using namespace std;
const int BUF = 512;
class JustTesting{
  private:
    string words;
    int number;
  public:
    JustTesting(const string & s = "Just Testing", int n = 0)
    {words = s; number = n; cout << words << " constructed\n.";}
    ~JustTesting(){cout << words << " destroyed\n";}
    void Show() const { cout << words << ", " << number << endl;}
};
int main(){
  char * buffer = new char[BUF];	// get a block of mem
  JustTesting *pc1, *pc2;
  pc1 = new(buffer) JustTestng;			// place object in buffer
  pc2 = new JustTesting("Heap1", 20); 	// place object on heap

  cout << "Memory block address:\n" << "buffer: "
       << (void *) buffer << "\theap: " << pc2 << endl;
  cout << "Memory contents:\n" << pc1 << ": ";
  pc1->Show();
  cout << pc2 << ": ";
  pc2->Show();

  JustTesting *pc3, *pc4;
  pc3 = new(buffer) JustTestng("Bad Idea", 6);	// place object in buffer
  pc4 = new JustTesting("Heap2", 10);		 	// place object on heap

  cout << "Memory contents:\n" << pc3 << ": ";
  pc3->Show();
  cout << pc4 << ": ";
  pc4->Show();

  delete pc2;	// free Heap1
  delete pc4;   // free Heap2
  delete [] buffer; // free buffer
  cout << "Done\n";
  return 0;
}

发生错误,未知原因

placement1.cpp: error: 'JustTesting' does not name a type
	pc1 = new(buffer) JustTestng;   // place object in buffer
error: expected type-specifier before ‘JustTestng’
	pc3 = new(buffer) JustTestng("Bad Idea", 6); // place object in buffer

以上程序在使用placement new运算符时存在两个问题:

  • 创建*pc2时,placement new运算符使用一个新对象来覆盖用于第一个对象的内存单元。如果类动态地为其成员分配内存,将引发问题
  • 将delete用于pc2和pc4时,自动为二者指向的对象调用析构函数;然而,将delete[]用于buffer时,不会为使用placement new运算符创建的对象调用析构函数。

delete不能与placement new运算符配合使用。解决方案:显式地为使用placement new运算符创建的对象调用析构函数。

pc1->~JustTesting(); // destroy object pointed to by pc1

5. 复习各种技术

5.1 重载<<运算符

以便和cout一起使用以显示对象内容。定义以下友元运算符函数:

ostream & operator<<(ostream & os, const c_name & obj){
  os << obj; // display object contents
  return os;
}

5.2 转换函数

将单个值转换为类类型,创建原型如下的类构造函数:
c_name(type_name value);
要将类转换为其他类型,创建原型如下的类成员函数:
operator type_name();
该函数虽然没有声明返回类型,但是需要返回所需类型的值。

使用转换函数需要小心。可以在声明构造函数时使用关键字explicit,以防止转换函数被用于隐式转换。

5.3 构造函数使用new的类

对于指向的内存是由new分配的所有类成员,都应该在类的析构函数中对其使用delete释放分配的内存。
如果析构函数通过对指针类成员使用delete释放内存,则每个构造函数都应当使用new来初始化指针,或者将其设置为空指针nullptr
应定义一个分配内存的复制构造函数,将类对象初始化为另一个类对象。
应定义一个重载赋值运算符的类成员函数c_name & c_name::operator=(const c_name & cn);

6. 队列模拟

6.1 队列类Queue

class Queue{
  private:
  // class scope definitions
    struct Node { Item item; struct Node * next;}; // 嵌套结构声明
    enum {Q_SIZE = 10};
    // private class members
    Node * front;
    Node * rear;
    int items;
    const int qsize;
    
  public:
    // Queue类的接口
    Queue(int qs=Q_SIZE);
    ~Queue();
    bool isempty() const;
    bool isfull() const;
    int queuecount() const;
    bool enqueue(const Item & item); // add item to end
    bool dequeue(Item & item);       // remove item from front
};

成员初始化列表(member initializer list)由逗号分隔的初始化列表组成,位于参数列表右括号之后、函数体左括号之前。由它完成常量成员的初始化以及被声明为引用的类成员的初始化。
只有构造函数可以使用这种初始化列表语法。

// public methods
Queue::Queue(int qs) : qsize(qs)
{
  front = rear = nullptr;
  items = 0;
  // qsize = qs; // not acceptable
}
// or
Queue::Queue(int qs) : qsize(qs), front(nullptr), rear(nullptr), items(0){}

C++11允许直接初始化:

class Classy{
  int mem1 = 10;
  const int mem2 = 20;
}
bool Queue::isempty() const{
  return items == 0;
}
bool Queue::isfull() const{
  return items == qsize;
}
int Queue::queuecount() const{
  return items;
}
bool Queue::enqueue(const Item & item){
  if(isfull())
    return false;
  Node * add = new Node;
  // on failure, new throws std::bad_alloc exception
  add->item = item;
  add->next = nullptr;
  items++;
  if(front == nullptr) front = add;
  else rear->next = add;
  rear = add;
  return true;
}
bool Queue::dequeue(Item & item){
  if(isempty())
    return false;
  item = front->item;
  items--;
  Node * temp = front;
  front = temp->next;
  delete temp;
  if(items==0)
    rear = nullptr;
  return true;
}

Queue::~Queue(){
  Node *temp;
  while(front != nullptr){
    temp = front;
    front = front -> next;
    delete temp;
  }
}

可以如下定义对象不允许被复制的类:

class Queue{
  private:
    Queue(const Queue q) : qsize(0) {} // preemptive definition
    Queue & operator=(const Queue & q) { return *this;}
};

C++11可以使用关键字delete实现上述功能(第18章)。

6.2 Customer类

class Customer{
  private:
    long arrive;	// arrival time
    int process_time; // processing time
  public:
    Customer() { arrive = process_time = 0; }
    void set(long when);
    long when() const { return arrive;}
    int ptime() const { return process_time;}
};

void Customer::set(long when){
  process_time = std::rand() % 3 + 1;
  arrive = when;
}
typedef Customer Item;

6.3 ATM模拟

// bank.cpp -- using the Queue
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "queue.h"
const int MIN_PER_HR = 60;

bool newcustomer(double x);  // is there a new customer?

int main(){
  using std::cin;
  using std::cout;
  using std::endl;
  using std::ios_base;
  // setting things up
  std::srand(std::time(0)); // random initializing of rand()
  cout << "Case Study: Bank of Heather Automatic Teller\n";
  cout << "Enter maximum size of queue: ";
  int qs;
  cin >> qs;
  Queue line(qs);

  cout << "Enter the number of simulation hours: ";
  int hours;
  cin >> hours;
  long cyclelimit = MIN_PER_HR * hours;
  cout << "Enter the average number of customers per hour: ";
  double perhour;
  cin >> perhour;
  double min_per_cust;
  min_per_cust = MIN_PER_HR / perhour;

  Item temp;  // new customer data
  long turnaways = 0;  // turned away by full queue
  long customers = 0;  // joined the queue
  long served = 0;     // served during the simulation
  long sum_line = 0;    // cumulative line length
  int wait_time = 0;    // time until autoteller is free
  long line_wait = 0;   // cumulative time in line
  // running the simulation
  for(int cycle = 0; cycle < cyclelimit; cycle++){
    if (newcustomer(min_per_cust)){
      if(line.isfull()) turnaways++;
      else{
        customers++;
        temp.set(cycle);
        line.enqueue(temp);
      }
    }
    if(wait_time <= 0 && !line.isempty()){
      line.dequeue(temp);
      wait_time = temp.ptime();
      line_wait += cycle - temp.when();
      served++;
    }
    if(wait_time > 0)  wait_time--;
    sum_line += line.queuecount();
  }
  // reporting results
  if (customers > 0){
    cout << "customers accepted: " << customers << endl;
    cout << "  customers served: " << served << endl;
    cout << "         turnaways: " << turnaways << endl;
    cout << "average queue size: ";
    cout.precision(2);
    cout.setf(ios_base::fixed, ios_base::floatfield);
    cout << (double) sum_line /cyclelimit << endl;
    cout << " average wait time: " << (double) line_wait/served << "minutes\n";
  }
  else
    cout << "No customers!\n";
  cout << "Done!\n";

  return 0;
}
bool newcustomer(double x){
  return (std::rand() * x / RAND_MAX < 1);
}
C++ Primer Plus(第六版)编程练习答案 所有章节汇总 本博客汇总了本人历时一年学完《C++ Primer Plus (第6版)》所做的所有编程练习的答案,供大家学习参考和交流。 以下附上各章节的答案详解博客地址,以及源码工程下载地址。 PS:源码下载大部分都是需要积分的,当时设置的时候好像有点乱,有的是1积分,有的是3积分,最难的第12章和第13章我设置的是不要积分,大家都可以下载下来自己运行一下看看结果。 第 2 章 开始学习C++: ... 阅读详情

相关推荐

C++ Primer Plus(第六版)编程练习答案 第12章 类和动态内存分配

本章所有编程练习的工程源码可在此处下载(点击此链接下载),供大家参考交流!   1. 对于下面的类声明: class Cow {          char name[20];          char *hobby;          double weight; public:          Cow();          Cow(const char * nm, co...

清水河C罗——Leonardo-Liu 4676

C++的Rule of Three

Rule of Three是国外的人提出来的一条法则,可运用于很多行业,在他们看来,数字3代表稳定,也让人觉得舒服。可以把它理解为三者法则,国内也有人翻译为三强鼎立法则。 C++中的Rule of Three指的是析构函数、拷贝构造函数和重载赋值函数三者之间的关系,具体指的是在一个类当中当你需要显式地定义这三个函数中的任意一个时,你应该同时显式地定义其它两个,也就是说这三个函数要么都不定义,要么

hmalloc的专栏 4948

C++ Primer Plus(第六版)编程练习答案 第13章 类继承

本章所有编程练习的工程源码可在此处下载(点击此链接下载),供大家参考交流!   1. 以下面的类声明为基础: {……代码省略……} 派生出一个Classic类,并添加一组char成员,用于存储指出CD中主要作品的字符串。修改上述声明,使基类的所有函数都是虚的。如果上述定义声明的某个方法并不需要,则请删除它。使用下面的程序测试您的产品: {……代码省略……}   本题提供了基类,但是该...

清水河C罗——Leonardo-Liu 3143

C++ Rule of Three

Rule of Three Therule of three(also known as the Law of The Big Three or The Big Three) is arule of thumbinC++(prior toC++11) that claims that if aclassdefinesone (or more) of the following...

weixin_34107955的博客 239

C++ Primer Plus学习(十一)——类和动态内存分配

类和动态内存分配

weixin_41480034的博客 802

MONAILabel in 3D Slicer 案例1: 在腹部CT中自动分割脾脏

MONAILabel in 3D Slicer 案例1: 在腹部CT中自动分割脾脏。

Tina姐的博客 1939

The Rule of Three

Rule of Three The rule of three (also known as the Law of The Big Three or The Big Three) is a rule of thumb in C++ (prior to C++11) that claims that if a class defines one of the followin

小猪爱拱地 1803

Verilog的综合指令

Synopsys综合指令

烟花一时的博客 5450

C++拷贝控制操作(三/五法则)

**三/五法则**的核心思想是: 如果一个类需要自定义拷贝构造函数、拷贝赋值运算符或析构函数,那么它很可能需要同时实现以下三或五种函数,以正确管理资源。

weixin_45613635的博客 626

5分钟搞定mmdetection3d多模态推理可视化:从KITTI数据集到3D检测结果展示

本文提供了一份快速上手MMDetection3D进行多模态推理可视化的实战指南。文章详细介绍了从环境搭建、KITTI数据集准备,到模型选择、配置解析,再到执行多模态推理并生成3D检测结果可视化的完整流程,旨在帮助开发者在30分钟内快速验证模型并直观展示检测效果。

weixin_29051149的博客 255

告别手动点鼠标:用Python脚本批量跑ADS版图仿真,效率提升10倍(附完整代码)

本文详细介绍了如何利用Python脚本自动化ADS版图仿真流程,显著提升射频工程师的工作效率。通过调用ADS底层接口,实现参数化修改、批量任务调度和结果自动收集,解决了手动操作中的常见问题,如仿真不更新等。附完整代码,帮助开发者快速实现10倍效率提升。

weixin_42523543的博客 338

c++ primer plus学习笔记_第12章 类和动态内存分配

c++ primer plus>第六版。

编程驴子的博客 2452

Python爬虫博客:如何抓取时事新闻信息 —— 从各大新闻网站获取实时新闻数据

发送请求:向目标新闻网站发送 HTTP 请求,获取网页内容。解析网页:使用解析库(如)从网页中提取新闻标题、摘要、内容、发布时间等。绕过反爬虫机制:使用代理、设置请求头、模拟浏览器行为等策略绕过反爬虫技术。数据存储与清洗:将抓取的数据保存到本地文件或数据库中,并进行清洗,确保数据的可用性。在抓取过程中,我们还会面对很多实际问题,比如反爬虫技术、分页抓取、动态加载的内容等。接下来,我们将逐步介绍如何使用不同技术抓取静态和动态网页,并对抓取的内容进行处理。Scrapy。

2201_76125261的博客 2139

C++ Primer Plus 学习笔记(第 12 章 类和动态内存分配)

C++ Primer Plus 学习笔记(第 12 章 类和动态内存分配)

whzpz77的博客 467

NVIDIA Isaac Sim scene_synthesizer 创建机器人操控任务场景使用教程

【摘要】Scene Synthesizer是一个用于3D场景程序化生成的Python库,专为机器人仿真训练设计。文章介绍了其安装方法(pip或git)和核心概念:1) 资产(Asset)系统支持多种3D模型格式和参数化尺寸调整;2) 场景(Scene)管理通过有向无环图组织对象,支持基于锚点的层级合成;3) 提供了丰富的程序化资产(如橱柜、货架、餐具等)和6个预定义厨房场景。该库采用仿真器无关架构,强调物理仿真的多样性和扩展性,相比现有数据集和生成模型能创建更复杂的交互场景,适用于机器人操作任务训练。

机器人控制与仿真应用 1151

planning模块(6)-参考线的平滑(二次规划)

上一篇已经介绍了采样点生成锚点数据的过程,并且将所有采样点生成的锚点数据设置到了平滑器中.接下来继续介绍使用二次规划平滑参考线的算法过程.从锚点数据中提取坐标存入raw_point2d,提取横向边界存入anchorpoints_lateralbound,将起点和终点的横向边界设置为0,防止车在起点和终点位置偏离车道中心线.

让复杂的问题变得更容易理解 790

【C++ Primer Plus】学习笔记--第12章 类和动态内存分配

第12章目录12.1 动态内存和类复习示例和静态类成员特殊成员函数默认构造函数复制构造函数默认复制构造函数(浅复制)浅复制带来的问题深度复制构造函数赋值运算符12.2 改进后的新 String 类修正后的默认构造函数空指针比较成员函数使用中括号表示法访问字符静态类成员函数String 类程序12.3 在构造函数中使用new时应注意的事项12.4 有关返回对象的说明返回指向const对象的引用返回指向非const对象的引用返回对象返回const对象总结12.5 使用指向对象的指针指针和对象小结定位new运算符

Ref.Ptr.的博客 997

某智能物流无人值守系统 ExportReport SQL注入漏洞复现

某智能物流无人值守系统 ExportReport存在SQL注入漏洞,未经身份验证的远程攻击者除了可以利用 SQL 注入漏洞获取数据库中的信息(例如,管理员后台密码、站点的用户个人信息)之外,甚至在高权限的情况可向服务器中写入木马,进一步获取服务器系统权限。

0xSec 823

C++_primer_plus学习笔记 第12章 类和动态内存分配

对类成员使用动态内存分配 隐式和显式复制构造函数 隐式和显式重载赋值运算符 在构造函数中使用new所必须完成的工作 使用静态类成员 将定位new运算符用于对象 使用指向对象的指针 实现队列抽象数据类型......

Flying_Dutchman_的博客 629

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

《C++ Primer Plus》第12章 类和动态内存分配 学习笔记

本章介绍了定义和使用类的许多重要方面。其中的一些方面是非常微妙甚至很难理解的概念。如果其中的某些概念对于您来说过于复杂,也不用害怕——这些问题对于大多数C++的初学者来说都是很难的。通常,对于诸如复制构造函数等概念,都是在由于忽略它们而遇到了麻烦之后逐步理解的。本章介绍的一些内容乍看起来难以理解,但是随着经验越来越丰富,对其理解也将越透彻。在类构造函数中,可以使用new为数据分配内存,然后将内存地...

weixin_34381666的博客 109

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

带你学《C++ Primer Plus》

This blog anncounces the updating plan of the Object Oriented Programming Section of C++, based on the classic textbook "C++ Primer Plus"

yangxiyuan_的博客 2535

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

C++Primer Plus学习笔记

此博文是通过翻阅C++ Primer Plus中文第6版(2020),逐章学习记录笔记由此学习C++的基础特性和语法知识,有别于其它视频教学+代码+笔记的学习途径,更趋向传统的书籍+代码+笔记学习,Cpp第6版以C++11标准为主,学习C++基础编程绰绰有余.

weixin_45068267的博客 3200

【C++ primer plus】类和动态内存分配

这里将要讲述类和动态内存分配1 动态内存分配和类首先我们复习了new和delete的用法其次就是静态存储的一些操作,如enum和static这两个使用的方法最后就是这个常量的赋值一般都是在方法文件里面,因为如果我们定义在class里面,那么每一次引用就要进行一次初始化,这样会出现多个初始化副本,这样就会出现重名错误,我们要牢记,这个常量不是对于每个成员的,而是公用的2 特殊成员函数默认构造和析构函数,复制构造函数,运算符重载函数。

2401_86738532的博客 814

【C++ Primer Plus】第12章 类和动态内存分配

对类成员使用动态内存分配。 隐式和显式复制构造函数。 隐式和显式重载赋值运算符。 在构造函数中使用new所必须完成的工作。 使用静态类成员。 将定位new运算符用于对象。 使用指向对象的指针。 实现队列抽象数据类型(ADT)。

chaiky的博客 1616

C++ Primer Plus12章 类和动态内存分配

12章 类和动态内存分配 1. 动态分配内存的原因 为了避免大量的内存被浪费,一般采用在程序运行时,而不是编译时,确定诸如使用多少内存的问题。 C++使用new和delete运算符来动态控制内存。 2. 在构造函数中使用new的注意事项 2.1 在构造函数中使用new,在析构函数中必须使用delete。 1.为何需要分配内存: 如果不分配内存,直接用str=s,只会保存参数字符串的地址,并没有创...

LJFYYJ的博客 377
上一篇: C++ Primer Plus学习笔记11-使用类
actually_ture
博客等级 码龄9年 2粉丝 20原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值