C++学习系列笔记（三）

2019-06-01 20:55:13 阅读：219 来源： 互联网

标签：系列析构 Buffer 笔记 C++ Human class string 构造函数

1、类和对象
声明类使用关键字class，并在他后面依次包含类名、一组放在{ }内的成员属性和方法以及结尾的分号。

class Human
{
    //Data attributes:
    string Name;
    string Gender;
    //Methods:
    void Talk(string TextToTalk);
    void IntroduceYouself( );
    ……
} ;

就像int分配动态内存一样，也可以使用new为Human对象动态的分配内存;

Human* pAnotherHuman = new Human();  //动态的分配内存
delete pAnotherHuman;

使用句点运算符来访问成员

Human Tom;
Tom.DateBirth="1970";

使用指针运算符（->）访问成员
如果对象是使用new在自有储存区中实例化的，或者有指向对象的指针，则可以使用指针运算符（->）来访问成员属性和方法。

Human* pTom=new Human();
pTom->DataOfBirth="1970";
pTom->IntroduceYouself();
delete pTom;

下面结合代码来看一下：

#include<iostream>
#include<string>
using namespace std;
        class Human
        {
        private:
               string Name;
               int Age;
        public:
               void SetName(string HumansName)
               {
                       Name = HumansName;
               }
               void SetAge(int HumansAge)
               {
                       Age = HumansAge;
               }
               void IntroduceSelf()
               {
                       cout << "I am" + Name << "and am";
                       cout << Age << "years old" << endl;
               }
        };
        int main()
        {
               Human FirstMan;
               FirstMan.SetName("Adam");
               FirstMan.SetAge(30);
               FirstMan.IntroduceSelf();
        }

2、构造函数
构造函数是一种特殊的函数，它与类同名且不返回任何值。因此，Human类在声明内的构造函数声明类似于下面：

class Human
{
 public:
    Human( )
    {
          //代码
    }
}；

在类声明外定义构造函数的代码如下：

class Human
{
public:
    Human( );
 };
 Human :: Human()
 {
    //代码
 }

：：被称为作用域解析运算符。例如：Human::DateOfBirth指的是在Human类中声明的变量DateOfBirth，而::DateOfBirth表示全局作用域中的变量DateOfBirth。
包含初始化列表的构造函数的代码如下：

class Human
{
public:
  Human(string InputName = "Adam" , int Age = 25 )
            : Name(InputName) , Age(InputAge)
  {
        //代码
  }
}；

初始化列表由包含在括号当中的参数声明后面的冒号标识，冒号后面列出了各个成员变量及其初始化值。初始化值可以是参数，也可以是固定的值。
3、析构函数
析构函数在对象销毁时自动被调用。析构函数看起来也像一个与类同名的函数，但前面有一个波浪号（~）。因此，Human类的析构函数声明类似于下面这样,这是在类里面声明：

class Human
{
public:
    ~Human( )
    {
        // code here
    }
};

在类声明外定义析构函数：

class Human
{
public:
    ~Human();
};
Human::~Human()
{
    //code here
}

析构函数与构造函数的作用完全相反。析构函数是重置变量以及释放动态分配的内存和其他资源的理想场所。
析构函数典型代码如下：

#include<iostream>
#include<string>
using namespace std;
class MyString
{
private:
        char* Buffer;
public:
        MyString(const char* InitialInput)
        {
               if (InitialInput != NULL)
               {
                       Buffer = new char[strlen(InitialInput + 1)];
                       strcpy(Buffer, InitialInput);
               }
               else
                       Buffer = NULL;
        }
        ~MyString()
        {
               cout << "Invoking destructor,cleaning up" << endl;
               if (Buffer != NULL)
                       delete[] Buffer;
        }
        int GetLength()
        {
               return strlen(Buffer);
        }
        const char* GetString()
        {
               return Buffer;
        }
};
int main()
{
        MyString SayHello("Hello from string class:");
        cout << "string buffer in MyString is:" << SayHello.GetLength();
        cout << "characters long" << endl;
        cout << "Buffer contains:";
        cout << "Buffer contains:" << SayHello.GetString();
}

程序运行输出为：

string buffer in MyString is:24characters long
Buffer contains:Buffer contains:Hello from string class:Invoking destructor,cleaning up

析构函数不能重载，每个类都只能有一个析构函数。如果你忘记实现一个析构函数，编译器将创造一个伪（dummy）析构函数并调用他。伪析构函数为空，既不释放动态分配的内存。
复制构造函数
浅复制：复制类对象时，将复制其指针成员，都不复制指针指向的缓冲区，造成两个对象指向同一块动态分配的内存，会威胁程序的稳定性。
深复制：所以要将浅复制的参数复制变成地址传递，即按参数引用传递而不是进行二进制复制。代码示例如下

#include<iostream>
#include<string>
using namespace std;
class MyString
{
private:
        char* Buffer;
public:
        MyString(const char* InitialInput)
        {
               cout << "Constructor:creating new String" << endl;
               if (InitialInput != NULL)
               {
                       Buffer = new char[strlen(InitialInput + 1)];
                       strcpy(Buffer, InitialInput);
                       cout << "Buffer points to:0x" << hex;
                       cout << (unsigned int*)Buffer << endl;
               }
               else
                       Buffer = NULL;
        }
        //复制构造函数
        MyString(const MyString& CopySource)
        {
               cout << "copy constructeor:copy from MyString" << endl;
               f (CopySource.Buffer != NULL)
               {
                       Buffer = new char[strlen(CopySource.Buffer) + 1];
                       strcpy(Buffer, CopySource.Buffer);
                       cout << "Buffer points to:0x" << hex;
                       cout << (unsigned int*)Buffer << endl;
               }
               else
                       Buffer = NULL;
        }
        ~MyString()
        {
               cout << "Invoking destructor,cleaning up" << endl;
               if (Buffer != NULL)
                       delete[] Buffer;
        }
        int GetLength()
        {
               return strlen(Buffer);
        }
        const char* GetString()
        {
               return Buffer;
        }
};
void UseMyString(MyString Input)
{
        cout << "Sting Buffer in mystring is" << Input.GetLength();
        cout << "characters long" << endl;
        cout << "Buffer contains:" << Input.GetString() << endl;
        return;
}
int main()
{
        MyString SayHello("Hello from string class:");
        UseMyString(SayHello);
}

程序运行输出：

Constructor:creating new String
Buffer points to:0x004BD5A0
copy constructeor:copy from MyString
Buffer points to:0x004BD5E8
Sting Buffer in mystring is18characters long
Buffer contains:Hello from string class:
Invoking destructor,cleaning up
Invoking destructor,cleaning up

MyString包含原始指针成员char* Buffer，一般不要为类成员声明原始指针，而应该使用std::string。在没有原始指针的情况下，都不需要编写复制构造函数，这是因为编译器添加的默认复制构造函数将调用成员对象（如：std::string）的复制构造函数。

标签：系列,析构,Buffer,笔记,C++,Human,class,string,构造函数
来源： https://blog.csdn.net/xiewenrui1996/article/details/90732871

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

C++学习系列笔记（三）