C++类和动态内存分配

最新推荐文章于 2021-03-24 13:58:22 发布

没有梦想__何必远方

最新推荐文章于 2021-03-24 13:58:22 发布

阅读量750

点赞数 1

分类专栏： C++学习笔记文章标签： c++学习之类和动态

本文链接：https://blog.csdn.net/u013271921/article/details/44514949

版权

C++学习笔记专栏收录该内容

17 篇文章 1 订阅

订阅专栏

注：本文章仅供个人复习使用。
在这里定义了一个String类，并重载了各种操作符。
String.h:

#include <iostream>
#ifndef STRNGBAD_H_
#define STRNGBAD_H_

class String
{
private:
    char * str;
    int len;
    static int num_strings; //静态类成员，所有对象共享一个静态成员
    static const int CINLIM = 80;
public:
    String(const char * s);
    String();
    ~String();
    String(const String & st); //复制构造函数
    int length()const{return len;}  //内联函数

    String & operator=(const String & st);  //赋值操作符只能由类成员函数重载
    String & operator=(const char *);
    char & operator[](int i);  //[]下标操作法只能有类成员函数重载
    const char & operator[](int i)const;
    friend std::ostream & operator<<(std::ostream & os,const String &st);
    friend bool operator<(const String &st1,const String &st2);
    friend bool operator>(const String &st1,const String &st2);
    friend bool operator==(const String &st1,const String &st2);
    friend std::ostream & operator<<(std::ostream & os,const String & st);
    friend std::istream & operator>>(std::istream & is,String & st);

    static int HowMany();

};

#endif

String.cpp:

#include <cstring>
#include "String.h"

//initializing static class member
int String::num_strings = 0;

//class methods

//construct StringBad from C string
String::String(const char * s)
{
    len = std::strlen(s);
    str = new char[len + 1];
    std::strcpy(str,s);
    num_strings++;
    //std::cout<<num_strings<<": \""<<str<<"\"object created\n";
}
String::String()
{
    len = 4;
    str = new char[1];
    //std::strcpy(str,"C++");
    str[0] = '\0';
    num_strings++;
    //std::cout<<num_strings<<": \""<<str<<"\"default object created\n";
}
String::String(const String & st)
{
    num_strings++;
    len = st.len;
    str = new char[len + 1];
    std::strcpy(str,st.str);
    //std::cout<<num_strings<<": \""<<str<<"\"object created\n";
}
String::~String()  //必须要有析构函数！！！
{
    //std::cout<<"\""<<str<<"\"object deleted, ";
    --num_strings;
    //std::cout<<num_strings<<" left\n";
    delete [] str;
}
String & String::operator=(const String & st)
{
    if(this == &st)
        return *this;
    delete[] str;
    len = st.len;
    str = new char [len + 1];
    std::strcpy(str,st.str);
    return *this;
}
String & String::operator=(const char * s)
{
    delete []str;
    len = std::strlen(s);
    str = new char[len + 1];
    std::strcpy(str,s);
    return *this;
}
char & String::operator[](int i)
{
    return str[i];
}
const char & String::operator[](int i)const
{
    return str[i];
}
bool operator<(const String & st1,const String & st2)
{
    return (std::strcmp(st1.str,st2.str) < 0);
}
bool operator>(const String & st1,const String & st2)
{
    return st2.str < st1.str;
}
bool operator==(const String & st1,const String & st2)
{
    return (std::strcmp(st1.str,st2.str) == 0);
}
std::ostream & operator<<(std::ostream & os,const String & st)
{
    os<<st.str;
    return os;
}
std::istream & operator>>(std::istream & is,String & st)
{
    char temp[String::CINLIM];
    is.get(temp,String::CINLIM);
    if(is)
        st = temp;
    while(is && is.get()!='\n')
        continue;
    return is;
}
int String::HowMany()
{
    return num_strings;
}

以上是对String类里的成员函数的定义，这里要注意的是定义了三个构造函数用来初始化String类对象，而且都是用new来动态分配的内存，所以一定要用delete来释放内存。如果是用的new[ ]来分配内存，则需要用delete[ ]来释放内存。
下面主要说一下复制构造函数，当使用一个对象来初始化另外一个对象时，编译器会自动生成复制构造函数。具体来说C++自动提供了下面这些成员函数：

默认构造函数，如果程序员没有定义构造函数。
复制构造函数，如果程序员没有定义。
赋值操作符，如果程序员没有定义。
默认析构函数，如果程序员没有定义。
地址操作符，如果程序员没有定义。

1.默认构造函数
如果没有提供任何构造函数，C++将创建默认构造函数例如：String::String( ){ }，也就是说编译器将提供一个不接受任何参数，也不执行任何操作的构造函数，这是因为创建对象时总是会调用构造函数。

2.复制构造函数
复制构造函数用于将一个对象复制到新创建的对象中。也就是说，它用与初始化过程中，而不是常规的赋值过程中。类的复制构造函数原型通常如下：
class_name (const class_name &);
它接受一个指向类对象的常量作为引用参数，例如，String类的复制构造原型如下：
String (const String &);
对于复制构造函数，需要知道两点：何时调用，有何功能。

（1）何时调用复制构造函数
新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。例如假设metoo是一个String类的对象，则下面四种声明都将调用复制构造函数：
String ditto (metoo);
String metoo = motoo;
String also = String (motto);
String * pString = new String (motoo);
当函数按值传递对象或返回对象时，都将使用复制构造函数。记住，按值传递意味着创建原始变量的一个副本。由于按值传递对象将调用复制构造函数，因此应该按引用传递对象。

（2）复制构造函数的功能
默认的复制构造函数逐个复制非静态成员（成员复制也称为浅复制），复制的是成员的值。下述语句
String a = b;
与下面的代码等效
String a;
a.str = b.str;
a.len = b.len;
如果成员本身就是类对象，则将使用这个类的复制构造函数来复制成员对象。静态函数不受影响，因为它们属于整个类，而不是各个对象。

（3）复制构造函数哪里出了问题？
默认的复制构造函数不说明其行为，因此它不指出创建进程，也不增加计数器num_strings的值。但是析构函数更新了记数，并且在任何对象过期时都将被调用，而不管对象是如何被创建的。
此图表示了用复制构造函数来逐个复制成员的情况
上图表示了用默认的复制构造函数来逐个复制成员。

两个指针指向同一个字符串，但显示时不会有问题，但是当释放这两个指针所指向
的内存就会出现问题，先释放ditto.str指针指向的内存
delete [ ] ditto.str;
这里没有问题，再释放motoo.str指针指向的内存
delete [ ] motoo.str；
这里就会出现问题，它试图释放已经被释放过的内存。这将导致不确定的，可能有害的后果。

（4）.使用显示复制的构造函数来解决问题
解决上述问题的方法是进行深度复制。也就是说，复制构造函数应当复制字符串并将副本的地址赋给str成员，而不仅仅是复制字符串地址。这样每个对象都有自己的字符串，而不是引用另一个对象的字符串。调用析构函数时都将释放不同的字符串，而不会试图去释放已经被释放的字符串。可以这样编写Sting类的复制构造函数：

String::String (const String & st)
{
    num_strings++;
    len = st.len;
    str = new char[len + 1];
    std::strcpy(str,st.str);
}

必须定义复制构造函数的原因在于，一些类成员是使用new初始化的、指向数据的指针，而不是数据本身，
下图说明了深度复制

深度复制
注意：如果类中包含了使用new初始化的指针成员，应当定义一个复制构造函数，以复制指向的数据，而不是指针，这被称为深度复制。浅复制只是复制指针值。

3.赋值操作符
并不是所有的问题都归咎于默认的复制构造函数，还需要看一看默认的赋值操作符：
class_name & class_name::operator=(const class_name &);
它接受并返回一个指向类对象的引用。

（1）何时使用赋值操作符
将已有的对象赋给另一个对象时，将使用重载的赋值操作符：
String a(“I’m ZhaoLong.”);
…
String b;
b = a;
初始化对象时，并不一定会使用赋值操作符：
String b = a;
这里a是一个新创建的对象，被初始化为b的值，因此使用复制构造函数。不过，实现时也可能分成两步：使用复制构造函数来创建一个临时对象，然后通过赋值将临时对象的值复制到新对象中。这就是说，初始化总是会调用复制构造函数，而使用 = 操作符时也可能调用赋值操作符。

（2）赋值操作符的功能
与复制构造函数相似，赋值操作符的隐式实现也对成员进行逐个复制。如果成员本身就是类对象，则程序将使用为这个类定义的赋值操作符来复制该成员，但静态数据成员不受影响。

（3）赋值的问题在哪里？
与隐式复制构造函数相同：数据受损。这也是成员复制的问题，即导致motoo.str 和 ditto.str指向相同的地址。

（4）解决赋值的问题
对于默认赋值操作符不合适而导致的问题，解决方法是提供赋值操作符（进行深度复制）定义。其实现与复制构造函数相似，但也有一些差别。

由于目标对象可能引用了以前分配的数据，所以函数应使用delete [ ]来释放这些数据。
函数应当避免将对象赋给自身；否则，给对象重新赋值之前，释放内存操作可能删除对象的内容。
函数返回一个指向调用对象的引用。
下面代码说明了如何为String类编写赋值操作符：

String & String::operator=(const String & st)
{
    if(this == &st)
        return *this;
    delete [ ] str;
    len = st.len;
    str = new char [len+1];
    std::strcpy(str,st.str);
    return *this;
}

代码首先检测自我复制，这是通过查看赋值操作符右边的地址（&st）是否与接收对象（this）的地址相同来完成的。如果相同，程序将返回*this，然后结束。前面介绍过，赋值操作符是只能有类成员函数重载的操作符之一。

如果地址不同，函数释放str指向的内存，这是因为稍后将把一个新字符串的地址赋给str。如果不首先使用delete操作符，则上述字符串将保留在内存中，由于程序中不再包含指向该字符串的指针，因此这些内存会被浪费掉。

接下来的操作与复制构造函数相似，即为新字符串分配足够的内存空间，然后将赋值操作符右边的对象中的字符串赋值到新的内存单元中，并返回*this。

（5）进一步重载赋值操作符
为提高处理效率，最简单的方法就是重载赋值操作符，使之能够直接使用常规字符串，这样就不用创建和删除临时对象了。下面是一种可能的实现：

String & String::operator=(const char * s)//const String & st -> const char * s
{
    delete []str;
    len = std::strlen(s);
    str = new char [len+1];
    std:strcpy(str,s);
    return *this;
}

一般来说，必须释放str指向的内存，并为新字符串分配足够的内存。

4.有关返回对象的说明
当成员函数或独立的函数返回对象时，有几种方式可供选择。可以返回指向对象的引用，指向对象的const引用或const对象。
注意：如果方法或函数要返回局部对象，则应返回对象，而不是指向对象的引用。在这种情况下，将使用复制构造函数来生成返回的对象。如果方法或函数要返回一个没有公有复制构造函数的类（如ostream）的对象，它必须返回一个指向这种对象的引用。最后，有些方法和函数（如重载赋值操作符）可以返回对象，也可以返回引用，在这种情况下，应首选引用，因为其效率更高。
main.pp:

#include <iostream>
#include "String.h"
const int Arsize = 10;
const int MaxLen = 81;

int main()
{
    using std::cout;
    using std::cin;
    using std::endl;
    String name;
    cout<<"Hi what's your name?\n";
    cin>>name;
    cout<<name<<", please enter up to"<<Arsize<<" short sayings <empty line to quite>:\n";
    String sayings[Arsize];
    char temp[MaxLen];
    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')
            break;
        else
            sayings[i] = temp;
    }

    int total = i;
    cout<<"Here are your asyings:\n";
    for(i = 0;i < total;i++)
        cout<<sayings[i][0]<<": "<<sayings[i]<<endl;

    int shortest = 0;
    int first = 0;
    for(i = 1;i < total;i++)
    {
        if(sayings[i].length() < sayings[shortest].length())
            shortest = i;
        if (sayings[i] < sayings[first])
            first = i;
    }
    cout<<"Shortest saying:\n"<<sayings[shortest]<<endl;
    cout<<"First salphabetically:\n"<<sayings[first]<<endl;
    cout<<"This program used "<<String::HowMany()<<" String objects. Bye.\n";
    return 0;
}