C++ Primer Plus 学习笔记第十二章对象指针小总结下

向右看齐 2022-01-26 06:29 195阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 3][]

如果是通过定位new运算符创建的对象 在释放内存的时候不会调用对象的析构函数

char * buffer = new char[BUF];
    
    pc1 = new (buffer) JustTesting;
    
    delete [] buffer;
    
    // 这时候是不会调用~JustTesting()的

使用定位new运算符时 要手动的空值内存位置 不然一不小心就把之前见的对象覆盖掉了

pc3 = new (buffer + sizeof(JustTesting))  JustTesting("Better Idea", 6);

正常情况下 使用定位new 运算符时  delete \[\] 会有释放掉内存 但是如果依然希望程序能够调用析构函数的话

就显式的调用

pc1->~JustTesting();

我这里测试出来一个事情：

当调用析构函数后（定位new） 指针依然能够使用 当执行delete \[\] 释放数组之后才会出现数据异常的情况

如果是正常的new出来的对象 调用析构函数之后 对象指针就没用了

构造函数初始化对象const常量类型的成员时不能直接赋值。 因为人家是常量。需要在程序执行到构造函数体之前进行赋值：

Queue::Queue(int qs) : qsize(qs)
    
    {
        front = rear = NULL;
        items = 0;
    }

这种用法仅限于构造函数。 :号后面的成员数量可以不止一个，const和声明为引用的类成员必须用这个方法赋值。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 4][]

![20190528151352300.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 9][]

最后那个队列模式

其实就是单链表

// queue.h
    
    
    #ifndef QUEUE_H_
    #define QUEUE_H_
    
    class Customer
    {
      private:
        long arrive;
        int processtime;
      public:
        Customer() {arrive = processtime = 0;}
    
        void set(long when);
        long when() const {return arrive;}
        int ptime() const {return processtime;}
    };
    
    typedef Customer Item;
    
    class Queue
    {
      private:
        struct Node {Item item; struct Node * next;};
        enum {Q_SIZE = 10};
    
        Node * front;
        Node * rear;
        int items;
        const int qsize;
        Queue(const Queue & q) : qsize(0) {}
        Queue & operator=(const Queue & q) {return *this;}
      public:
        Queue(int qs = Q_SIZE);
        ~Queue();
        bool isempty() const;
        bool isfull() const;
        int queuecount () const;
        bool enqueue(const Item &item);
        bool dequeue(Item &item);
    };
    
    #endif

// queue.cpp
    
    #include "queue.h"
    #include <cstdlib>
    
    Queue::Queue(int qs) : qsize(qs)
    {
      front = rear = NULL;
      items = 0; 
    }
    
    Queue::~Queue()
    {
      Node * temp;
      while (front != NULL)
      {
        temp = front;
        front = front->next;
        delete temp;
      }
    }
    
    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;
      add -> item = item;
      add->next = NULL;
      items++;
      if (front == NULL)
        front = add;
      else
        rear -> next = add;
      rear = add;
      return true;
    }
    
    bool Queue::dequeue(Item & item)
    {
      if (front == NULL)
        return false;
      item = front -> item;
      items--;
      Node * temp = front;
      front = front -> next;
      delete temp;
      if (items == 0)
        rear = NULL;
      return true;
    }
    
    void Customer::set(long when)
    {
      processtime = std::rand() % 3 + 1;
      arrive = when;
    }

bank.cpp
    
    #include <iostream>
    #include <cstdlib>
    #include <ctime>
    #include "queue.h"
    const int MIN_PER_HR = 60;
    
    bool newcustomer(double x);
    
    int main()
    {
      using std::cin;
      using std::cout;
      using std::endl;
      using std::ios_base;
      std::srand(std::time(0));
    
      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;
      long turnaways = 0;
      long customers = 0;
      long served = 0;
      long sum_line = 0;
      int wait_time = 0;
      long line_wait = 0;
    
      for (int cycle = 0; cycle < cyclelimit; cycle++)
      {
        if (newcustomer(min_per_cust))
        {
          if (line.isfull())
            turnaways++;
          else
          {
            customers++;
            temp.set(cycle);
            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();
      }
      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);
    }

总结：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 11][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70]: /images/20220126/554d564ea72f4126acb408bdd8d4c085.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 1]: /images/20220126/e6d8ac911b6c42cf854bba68c654ef15.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 2]: /images/20220126/d835e7ee5c1f4e4f90ea7185a9788ea6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 3]: /images/20220126/0be2f1445b224275aee920f0f887edda.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 4]: /images/20220126/3760d182b7cd49bca6f16fa1a58aad39.png
[20190528151352300.png]: /images/20220126/fb4b5d98d3304eb4a427e77b2abb603b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 5]: /images/20220126/92e114dd94f2415581cb3ea99907e7f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 6]: /images/20220126/6747b0df0aeb495b95a5ec35241bbbed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 7]: /images/20220126/88ccb48a577b4e8497aa12d708708d50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 8]: /images/20220126/9890e5d955ec4e339968cf2c1e8a1828.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 9]: /images/20220126/0e6697e8216c4f3fb787cce8f97a2a1c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 10]: /images/20220126/a2544991742a4dada569ede0f146efaa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 11]: /images/20220126/0f1ba05abffb4536b4de6e74553595a3.png