cpp_05_类_string类

1? 类的定义

1.1? ?构造函数

? ? ? ? 定义：函数名必须与类名相同，且没有返回值类型?，连void也没有。

? ? ? ? 构造函数调用时间：

? ? ? ? 在定义对象的同时自动被调用，而且仅被调用一次：

????????????????1）对象定义语句

????????????????2）new操作符

? ? ? ? 构造函数的作用：

????????????????1）设置? 对象的初始状态：定义对象的各个成员变量并赋初值。

? ? ? ? ? ? ? ? 2）执行? 在对象定义之初想实现的任何操作?。

// clsobj1.cpp
// 构造函数:(1)函数名必须与类名相同 (2)没有返回值类型
// 构造函数被调用的时间:定义对象的同时，自动被调用
// 构造函数的作用:定义对象的各个成员变量(造包子馅)
#include <iostream>
#include <cstring>
using namespace std;
class Human {
public:
    Human( /* Human* this */ int age=0, const char* name="无名") {
        // 在this所指向的内存空间中 定义m_age(给m_age分配内存空间),初值随机数
        // 在this所指向的内存空间中 定义m_name(给m_name分配内存空间),初值随机数
        cout << "Human类的构造函数被调用" << endl;
        m_age = age;
        strcpy( m_name, name );
    }
//    void setinfo( /* Human* this */ int age=0, const char* name="无名" ) { 
//        this->m_age = age;
//        strcpy( this->m_name, name ); 
//    }
    void getinfo( /* Human* this */ ) { 
        cout << "姓名:" << this->m_name << ", 年龄:" << this->m_age << endl;
    }
private:    
    int m_age; // 声明
    char m_name[256]; // 声明 
};
// 以上代码模拟类的设计者(标准库的类,第三方提供的类,自己设计的类)
// ------------------------
// 以下代码模拟类的使用者
int main( void ) {
    Human h(22,"张飞"); // 定义h (给h分配内存空间),利用h.Human(22,"张飞")

    cout << "h对象创建完毕" << endl; 
//    h.setinfo( 22,"zhangfei" ); 
    h.getinfo(); 
    return 0;

1.2? 对象的定义过程

? ? ? ? 定义对象，就是

? ? ? ? 1）给对象分配内存空间，

? ? ? ? 2）并利用对象调用构造函数：

? ? ? ? ? ? ? ? ? ? ? ? ①定义成员变量；

? ? ? ? ? ? ? ? ? ? ? ? ②执行用户在构造函数中书写的代码。

????????

2? 类的实例化（定义对象）的11种方法

2.1? 栈中，对象的定义和销毁

? ? ? ? 在栈中，定义单个对象：

? ? ? ? ? ? ? ? 01）类名? 对象;? ? //注意不要加空括号，加了误导编译器：返回值类型 函数名 形参表

? ? ? ? ? ? ? ? 02）类名? 对象( 实参表 );?

? ? ? ? 在栈中，定义对象数组：

? ? ? ? ? ? ? ? 03）类名? 对象数组[ 元素个数 ];?

? ? ? ? ? ? ? ? 04）类名? 对象数组[ 元素个数 ] = { 类名( 实参表 ), ... };? ? // 11）定义匿名对象，右值

? ? ? ? ? ? ? ? 05）类名? 对象数组[] = { 类名( 实参表 ), ...};?

2.2? 堆中，对象的定义和销毁

? ? ? ? 不是所有的匿名对象生命周期都短暂：new出来的对象（下面讲到），基类子对象

? ? ? ? 匿名的栈对象，生命周期短暂，语句级。

? ? ? ??

? ? ? ? 在堆中，定义/销毁单个对象

? ? ? ? ? ? ? ? 06）类名*? 对象指针 = new? 类名;? //定义相应类的堆对象，匿名对象。

????????????????07）类名*? 对象指针 = new? 类名();? //这里可以加空括号，同06，异于01

? ? ? ? ? ? ? ? 08）类名*? 对象指针 = new? 类名( 实参表 );?

? ? ? ? ? ? ? ? ? ? ? ? delete? 对象指针;

? ? ? ? 在堆中，定义/销毁对象数组

? ? ? ? ? ? ? ? 09）类名*? 对象数组指针 = new? 类名[ 元素个数 ];?

? ? ? ? ? ? ? ? 10）类名* 对象数组指针 = new? 类名[ 元素个数 ]{类名( 实参表 ), ...};? ? ?// 11标准

? ? ? ? ? ? ? ? ? ? ? ? delete[]? 对象数组指针;

// clsobj2.cpp 定义对象的11种方法
#include <iostream>
#include <cstring>
using namespace std;
class Human {
public:
    Human( /* Human* this */ int age=0, const char* name="无名") {
        // 在this所指向的内存空间中 定义m_age(给m_age分配内存空间),初值随机数
        // 在this所指向的内存空间中 定义m_name(给m_name分配内存空间),初值随机数
        cout << "Human类的构造函数被调用" << endl;
        m_age = age;
        strcpy( m_name, name );
    }
    void getinfo( /* Human* this */ ) { 
        cout << "姓名:" << this->m_name << ", 年龄:" << this->m_age << endl;
    }
private:    
    int m_age; // 声明
    char m_name[256]; // 声明 
};
// 以上代码模拟类的设计者(标准库的类,第三方提供的类,自己设计的类)
// ------------------------
// 以下代码模拟类的使用者
int main( void ) {
    Human(32,"马超").getinfo();

    Human h(22,"张飞"); // 定义h (给h分配内存空间),利用h.Human(22,"张飞")
    h.getinfo(); 

    Human h2; // 定义h2,利用h2.Human()
    h2.getinfo();

    Human h3[3]; // 定义了3个Human类对象,并分别利用这3个Human类对象.Human()
    for( int i=0; i<3; i++ ) {
        h3[i].getinfo();
    }

    Human h4[3] = { Human(22,"张飞"), Human(20,"赵云"), Human(25,"关羽") };
    for( int i=0; i<3; i++ ) {
        h4[i].getinfo();
    }

    Human h5[] = { Human(22,"张飞"), Human(20,"赵云"), Human(25,"关羽"), Human(45,"黄忠") };
    for( int i=0; i<sizeof(h5)/sizeof(h5[0]); i++ ) {
        h5[i].getinfo();
    }

    Human* ph = new Human; // 定义 Human类堆对象,利用 Human类堆对象.Human()
    (*ph).getinfo(); // ph->getinfo()
    delete ph;
    ph = NULL;

    Human* ph2 = new Human(); // 定义 Human类堆对象,利用 Human类堆对象.Human()
    (*ph2).getinfo();
    delete ph2;
    ph2 = NULL;

    Human* ph3 = new Human(18,"武松"); // 定义 Human类堆对象,利用 Human类堆对象.Human(18,"武松")
    (*ph3).getinfo();
    delete ph3;
    ph3 = NULL;

    Human*ph4 = new Human[3]; // 定义了 3个Human类堆对象,分别利用这3个Human类堆对象.Human()
    for( int i=0; i<3; i++ ) {
        ph4[i].getinfo();
    }
    delete[] ph4;
    ph4 = NULL;

    Human* ph5 = new Human[3]{ Human(18,"武松"), Human(19,"李逵"), Human(20,"鲁达") };
    for( int i=0; i<3; i++ ) {
        ph5[i].getinfo();
    }
    delete[] ph5;
    ph5 = NULL;

    return 0;
}

3? string类

? ? ? ? 是C++标准库中的类，在操作字符串方面优于char*? []? ：

? ? ? ? ? ? ? ? 1）string类是c++类，而char* []的c痕迹明显；

? ? ? ? ? ? ? ? 2）string类可直接 = 赋值/初始化，而char* []要用strcpy()。

3.1? string类的5种使用方法

? ? ? ? string? s1( "hello" );? ? ? ? ? ?//触发构造函数

? ? ? ? string? s2( s1 );? ? ? ? ?????????// 等同于 string? s2 = s1;? ? 触发构造函数

? ? ? ? string? s3;? ? s3 = s2;? ? ? ? // 触发拷贝复制函数调用

? ? ? ? string? s4 = "hello";? ? ? ? ? // 触发类型转换操作

? ? ? ? string? s5;? ? s5 = "hello";? ? ? ? // 触发类型转换操作

// string_pre.cpp C++标准库设计的string类
#include <iostream>
using namespace std;

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    string s1("hello"); // s1维护的字符串为"hello"
    cout << "s1:" << s1 << endl;

    // 如果在做初始化，并且“=”两边类型完全一致，那么=xxx 和 (xxx) 无差别
    
    string s2(s1); // = s1; // s2维护的字符串 和 s1维护的字符串 内容相同 
    cout << "s2:" << s2 << endl;
    
    string s3; // s3维护的字符串为空串
    cout << "s3被赋值前:" << s3 << endl;
    s3 = s2; // s3维护的字符串 和 s2维护的字符串 内容相同
    cout << "s3被赋值后:" << s3 << endl;

    // 只要“=”两边类型不一致，编译器首先要做类型转换操作

    string s4 = "hello"; // s4维护的字符串内容为"hello"
    cout << "s4:" << s4 << endl;
    
    string s5; // s5维护的字符串为空串
    s5 = "hello"; // s5维护的字符串内容为 "hello"
    cout << "s5:" << s5 << endl;
    return 0;
}

?

3.2? string类的内部实现原理

//string.cpp
#include <iostream>
using namespace std;

// C++标准库设计的string类(类中有一个私有成员变量 char*m_psz-->指向一个字符串)

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    string s1("hello"); // 定义s1,利用s1.string("hello")--->s1维护的字符串为"hello"
    cout << "s1:" << s1 << endl;

    // 如果在做初始化，并且“=”两边类型完全一致，那么=xxx 和 (xxx) 无差别
    
    string s2 =s1; //(s1) // 定义s2,利用s2.string(s1)--->s2维护的字符串 和 s1维护的字符串 内容相同 
    cout << "s2:" << s2 << endl;
    
    string s3; // 定义s3,利用s3.string()--->s3维护的字符串为空串
    cout << "s3被赋值前:" << s3 << endl;

    // 如果在做赋值，并且“=”两边类型完全一致，那么将触发 operator= 函数的调用
    s3 = s2; // s3.operator=(s2) --->s3维护的字符串 和 s2维护的字符串 内容相同
    cout << "s3被赋值后:" << s3 << endl;

    // 不管是初始化还是赋值，只要“=”两边类型不一致，编译器首先要做类型转换操作

    string s4 = "hello"; 
    // 定义 匿名string类对象,利用 匿名string类对象.string("hello")--->匿名string类对象维护的字符串为"hello"
    // string s4 = 匿名string类对象--->s4维护的字符串 和 匿名string类对象维护的字符串 内容相同
    // --->s4维护的字符串内容为"hello"
    //模式相当于s1 + s2
    cout << "s4:" << s4 << endl;
    
    string s5; // 定义s5,利用s5.string() --->s5维护的字符串为空串
    s5 = "hello"; 
    // 定义 匿名string类对象,利用 匿名string类对象.string("hello")--->匿名string类对象维护的字符串为"hello"
    // s5 = 匿名string类对象--->s5维护的字符串 和 匿名string类对象维护的字符串 内容相同
    //--->s5维护的字符串内容为 "hello"
    cout << "s5:" << s5 << endl;
    return 0;
}

// twoDimensional.cpp 设计一个二维坐标系的 类
#include <iostream>
using namespace std;

class TwoDimensional {
public:
    TwoDimensional( int x=0, int y=0 ) {
        // 在this指向的内存空间中 定义m_x初值为随机数
        // 在this指向的内存空间中 定义m_y初值为随机数
        m_x = x;
        m_y = y;
    }
    void getinfo( /* TwoDimensional* this */ ) { // 非常函数
        cout << "横坐标: " << m_x << ", 纵坐标: " << m_y << endl;
    }
private:
    int m_x; // 横坐标
    int m_y; // 纵坐标
};

int main( void ) {
    TwoDimensional a(100,300); // 定义a,利用a.TwoDimensional(100,300)
    a.getinfo( );

    return 0;
}