c++类和对象的详细介绍（二）

一，对象的动态建立和释放

1.什么是对象的动态建立和释放

　　通常我们创建的对象都是由C++编译器为我们在栈内存中创建的，我们无法对其进行生命周期的管理。所以我们需要动态的去建立该对象，因此我们需要在堆内存中创建对象和释放对象。在C语言中为我们提供了malloc()函数和free()函数来为我们提供在堆内存中分配变量的方式，但是在C++中引入了new和delete关键字来让我们动态的创建和释放变量。

2.new和delete关键字

new关键字是用来在堆内存中创建变量的，格式为：Type * ptr = new Type(常量/表达式); 其参数列表中的常量/表达式可以用来给变量初始化，也可以省略不写。其返回结果为该类型的指针。如果内存分配失败则返回空指针。
delete关键字是用来释放用new关键字创建的内存，格式为delete ptr(释放数组必须需要加中括号，delete [] ptr)。

3.new和delete关键字与malloc和free的区别

new关键字在分配内存的时候，会根据其创建的参数调用相应的类的构造函数。delete关键字会在释放内存之前，会首先调用类的析构函数释放对象中定义的内存。
malloc和free关键字不会去调用类的构造函数和析构函数。

4.new和delete关键字示例

# define _CRT_SECURE_NO_WARNINGS
# include<iostream>

using namespace std;

class Teacher
{
public:
    char * name;
    int age;
public:
    /* 无参构造函数 */
    Teacher()
    {
        name = NULL;
        age = 0;
        cout << "无参构造函数被执行..." << endl;
    }
    /* 有参构造函数 */
    Teacher(char * name, int age)
    {
        /* 在构造函数中分配堆内存 */
        this->name = new char[sizeof(name) + 1];
        /* 初始化成员变量 */
        strcpy(this->name, name);
        this->age = age;
        cout << "有参构造函数被执行..." << endl;
    }
    /* 拷贝构造函数 */
    Teacher(const Teacher &student)
    {
        /* 重新分配内存 */
        this->name = new char[sizeof(name) + 1];
        /* 初始化成员变量 */
        strcpy(this->name, name);
        this->age = age;
        cout << "拷贝构造函数被执行..." << endl;
    }
    /* 析构函数 */
    ~Teacher()
    {
        if (this->name != NULL)
        {
            delete [] this->name;
            this->name = NULL;
            this->age = 0;
        }
        cout << "析构函数被执行..." << endl;
    }
};

int main()
{
    /* 创建int变量,并释放 */
    int * a = new int;
    int * b = new int(100);
    delete a;
    delete b;
    /* 创建double变量,并释放 */
    double * c = new double;
    double * d = new double(10.1);
    delete c;
    delete d;
    /* 创建数组并释放 */
    char * e = new char[100];
    delete [] e;
    /* 创建对象并释放 */
    Teacher * stu1 = new Teacher("王刚",22);
    cout << "姓名:" << stu1->name << ",年龄:" << stu1->age << endl;
    Teacher * stu2 = new Teacher();
    delete stu1;
    delete stu2;
    /* 利用malloc和free创建对象,无法调用其构造和析构函数*/
    Teacher * stu3 = (Teacher *)malloc(sizeof(Teacher));
    free(stu3);
}

二，静态成员变量和静态成员函数

1.static关键字

　　static关键字用来声明类中的成员为静态属性。当用static关键字修饰成员后，该类所创建的对象共享static成员。无论创建了多少个对象，该成员只有一份实例。静态成员是与类相关的，是类的一种行为，而不是与该类的对象相关。

2.静态成员的概念

　　静态成员是类所有的对象的共享成员，而不是某个对象的成员，它在对象中不占用存储空间，这个成员属于整个类，而不属于具体的一个对象，所以静态成员变量无法在类的内部进行初始化，必须在类的外部进行初始化。比如定义一个学生类，那么学生对象总数可以声明为static，在构造方法中，对该变量进行加1，从而统计学生对象的数量。

3.静态成员变量总结

静态成员变量可以用static关键字定义，但是初始化必须在类的外面进行初始化。
静态成员变量可以被类及类的对象所访问和修改。
静态成员变量遵循类的访问控制原则，如果为private修饰，则只可以在类的内部和在类外面初始化的时候访问，不会再被其他方式访问。

4.静态成员函数总结

静态成员函数用static关键字定义，在静态成员函数中可以访问静态成员变量和静态成员函数，但不允许访问普通的成员变量和成员函数，因为普通的成员属于对象而不属于类。层次不一样。但是在普通成员中可以访问静态成员。
当静态成员函数在类中定义，但是在类的外面实现的时候，不需要再加static关键字。
静态成员函数没有this指针。

5.静态成员重点归纳

静态成员是类和类的对象的所有者，因此静态成员变量不能在类的内部进行初始化，必须在类的外部进行初始化。
静态成员依旧遵循private,protected,public的访问控制原则。
静态成员函数中没有this指针，不能访问普通的成员变量和成员函数，可以访问静态成员变量和成员函数，但是可以通过传递对象的方式访问普通成员。

6.静态成员变量演示

# include<iostream>

using namespace std;

class MyStudent
{
private:
    static int count;/* 学生对象总数 */
    char name[64];
    int age;
public:
    static int n;
public:
    MyStudent(char * name,int age)
    {
        strcpy(this->name, name);
        this->age = age;
        MyStudent::count++;/* 学生数量加1 */
    }
    void getCount()/* 普通成员函数访问静态成员变量 */
    {
        cout << "学生总数：" << MyStudent::count << endl;
    }
};
/* 静态成员变量初始化 */
int MyStudent::count = 0;
int MyStudent::n = 10;

int main()
{
    /* 测试静态成员变量 */
    MyStudent student1("王刚",22);
    student1.getCount();
    /* 对象和类方式访问静态成员变量 */
    student1.n = 100;
    MyStudent::n = 200;
}
复制代码
7.静态成员函数演示

复制代码
# include<iostream>

using namespace std;

class Test
{
private:
    int m;
public:
    static int n;
public:
    void setM(int m)
    {
        this->m = m;
        /* 访问静态成员函数 */
        test();
    }
public:
    static void xoxo();
    static void test()
    {
        n = 100;
        // m = 10; 不允许访问普通成员变量
        // int c = getM(); 不允许访问普通成员函数
        // this->m = 1000; this指针不存在
        cout << "static void test()函数..." << endl;
    }
};
/* 初始化静态成员 */
int Test::n = 10;
/* 类中声明,类外实现 */
void Test::xoxo()
{
    cout << "static void Test::xoxo" << endl;
}
int main()
{
    Test t;
    /* 普通成员函数访问静态成员函数 */
    t.setM(10);
    /* 成员函数的调用方式 */
    t.test();
    Test::test();
}

三，友元函数和友元类

1.友元函数

　　当我们定义类的时候，使用private关键字修饰成员变量(成员函数)，这样做到了访问控制。有些时候，我们需要让一些函数来访问对象的私有成员(属性或方法)，C++为我们提供了友元函数这个概念，所谓的友元函数就是指这个函数是这个类的好朋友，允许让这个函数访问这个类创建的对象的私有属性和私有方法。友元函数用friend函数来声明，友元函数的声明必须在类的内部，友元函数的实现必须要在类的外部（如果友元函数的实现也在内部，那还要用友元函数干什么？），友元函数的声明位置与访问控制符无关。

2.友元函数示例

# include<iostream>
using namespace std;

/* 定义点类 */
class Point
{
private:
    int x;
    int y;
    /* 友元函数的定义：求两点的距离 */
    friend int distance(Point &p1, Point &p2);
public:
    Point(int x, int y)
    {
        this->x = x;
        this->y = y;
    }
};
/* 友元函数的实现 */
int distance(Point &p1, Point &p2)
{
    int dx = p1.x - p2.x;
    int dy = p1.y - p2.y;
    return sqrt(dx*dx + dy*dy);
}

int main()
{
    Point p1(3, 4);
    Point p2(0, 0);
    int dis = distance(p1, p2);
    cout << "点(3,4)到原点的距离为：" << dis << endl;
}

3.友元类

若B类是A类的友元类，则B类的所有成员函数都是A类的友元函数。类B可以访问类A的所有私有属性和方法。
友元类通常被设计为一种对数据操作或者类之间传递消息的辅助类。

4.友元类示例

# include<iostream>
using namespace std;

/* 定义类A */
class A
{
private:
    int x;
    friend class B;/* 定义类B为类A的友元类 */
private:
    void setX(int x)
    {
        this->x = x;
    }
};

/* 定义类B */
class B
{
private:
    A AObj;
public:
    /* 类B的所有成员函数都是类A的友元函数,因此都可以访问类A的私有属性和方法 */
    void operater(int tmp)
    {
        AObj.setX(tmp);
    }
    void display()
    {
        cout << "类A的私有属性x = " << AObj.x << endl;
    }
};

int main()
{
    B b;
    b.operater(100);
    b.display();

    return 0;
}

四，C++中引用的基础知识

1.引用的基本概念

　　1.所谓的引用其实就是对变量起“别名”。引用和变量对应得是相同的内存，修改引用的值，变量的值也会改变，和指针类似。

　　2.引用在定义的时候必须要初始化，初始化后就用引用的对象绑定在一起了。

　　3.引用本身不是对象，不能定义引用的引用。

2.引用的意义

　　1.引用作为其他变量的别名存在，因此在一些场合可以用来替代指针。

　　2.引用相对于指针来说具有更好的可读性和实用性。

3.引用的定义方式

　　数据类型 &引用名称 = 变量;

# include<iostream>
using namespace std;

int main()
{
    // 定义变量a
    int a = 10;
    // 定义引用b
    int &b = a;

    return 0;
}

二，引用的本质

1.引用的本质剖析

# include<iostream>
using namespace std;

int main()
{
    // 定义变量a
    int a = 10;
    // 定义引用b
    int &b = a;
    // 引用一旦初始化，就不再改变本身所绑定的对象，因此引用很想一个const修饰的常量
    cout << "&a = " << &a << endl;
    cout << "&b = " << &b << endl;
    // 通过打印地址，发现变量和引用的地址相同，因此引用本质是一个指针

    return 0;
}

2.引用的本质分析

　　1.引用的初始化之后不允许被修改，因此引用是一个常量。

　　2.引用的地址和变量本身的地址一样。因此引用是一个指针。

　　3.引用的本质是一个常量指针，只是C++编译器帮助我们进行了自动取地址操作和解引用操作。

　　4.上述的案例的本质：int &b = a; 相当于 int * const b = &a;

三，引用的重点

1.引用作函数参数

　　引用作函数参数可以用来替代指针，在函数内部操作引用，就可以修改函数外部变量的值。

2.引用作函数返回值(此处涉及类的拷贝构造函数)

　　引用作函数返回值，如果返回的是栈变量，则实际返回的是该变量的一份拷贝。

3.指针引用

　　引用是指针类型的，例如：Teacher teacher = {“王刚”,21};Teacher * &t = &teacher;

4.常引用

　　使用变量初始化引用，使引用具有只读属性，保护了引用所指向的对象，防止被函数内部修改。

　　使用字面量初始化引用，例如：const int &a = 10;是可以的，这里会在编译期间对字面量常量分配内存空间。

五，命名空间(namespace)的基本概念以及由来

1.什么是标识符：

　　在C++中，标识符可以是基本的变量，类，对象，结构体，函数，枚举，宏等。

2.什么是命名空间：

　　所谓的命名空间是指标识符的可见范围。C++标准库中的所有的标识符都被定义在一个名为std的命名空间中。

3.C语言的命名空间：

　　在C语言中只有一个全局作用域，因此在C语言中所有的标识符共享一个命名空间，因此随着代码量的增大，标识符之间可能会重名。由此会造成一些命名问题。

4.针对C语言的问题，在C++中提出了命名空间的概念：

　　1.命名空间将全局作用域划分成不同的的部分。

　　2.不同的命名空间中的标识符可以重名而不会发生冲突。

　　3.全局作用域也叫做默认命名空间。

　　4.命名空间之间可以相互嵌套。

二，命名空间(namespace)的定义以及使用

1.命名空间的定义:

namespace 命名空间名称
{
……
}
2.命名空间的使用:

using namespace name; // 使用name这个命名空间
using namespace name::variable; // 使用name这个命名空间下的variable
std::cout << “Hello,NameSpace” << std::endl; // 直接使用这个命名空间中的标识符
::tmp = 0; // 使用默认命名空间的变量,默认情况下可以直接使用默认命名空间的所有标识符
3.域作用符::

　　域作用符用两个冒号(::)表示，用来访问命名空间下的标识符。

三，命名空间(namespace)实际案例

# include<iostream>

/* 定义命名空间n1 */
namespace n1
{
    /* 定义学生类 */
    class Student
    {
    public:
        char name[64];
        int    age;
    };
    /* 定义函数 */
    void printN1()
    {
        std::cout << "我是n1命名空间的printN1()" << std::endl;
    }
    /* 定义命名空间n2 */
    namespace n2
    {
        /* 定义变量n */
        int n = 0;
    }
}

// 在默认命名空间下定义变量a
int a = 100;

int main()
{
    // 使用命名空间n1,曝光n1的所有标识符,因此可以调用printN1()函数
    using namespace n1;
    printN1();
    // 使用命名空间n2,曝光n2的所有标识符,因此可以使用变量n
    using namespace n1::n2;
    // 直接使用指定命名空间下的标识符
    std::cout << n << std::endl;
    // 使用域作用符访问默认命名空间下的标识符
    ::a = -100;
}