菜鸟学习历程【28】面向对象编程（2）

对象初始化列表

类中如果有一个其它类的对象，而其他类没有无参构造函数时，无法初始化该类的对象，此时需要对象的初始化列表。

举个圆类与点类的例子进行说明：

class Point
{
public:
    Point(int x, int y)
    {
        m_x = x;
        m_y = y;
        printf("调用了点(%d, %d)的构造函数\n", m_x, m_y);
    }
private:
    int m_x;
    int m_y;
};

class Circle
{
public:
    Circle(int r, int x, int y) : p2(x, y), p1(2, 3), a(r)
    {
        m_r = r;
        cout<<"调用了圆的构造函数"<<endl;
    }
private:
    int m_r;
    Point p1;
    Point p2;
    const int a;
};

int main()
{
    Circle c1(2, 1, 0);
    return 0;
}

终端会打印如下：
调用了点(2， 3)的构造函数
调用了点(1， 0)的构造函数
调用了圆的构造函数

有几点需要说明一下：
1.对象初始化列表的优先级高于当前对象的构造函数执行；
2.对象的构造和在对象初始化列表中的位置无关，和在类中声明的顺序有关；
3.const常量必须在初始化中初始化。

---

对象的动态创建和释放

在C语言中，使用 malloc 和 free，实现在堆上空间的分配和释放
在C++中，使用 new 和 delete ，实现在堆上空间的分配和释放

区别：
malloc 和 free 是库函数，是C语言标准库中提供的，不是语法的一部分
new 和 delete 是C++运算符，是C++语法的一部分，效率高于 malloc 和 free

对比：

1.基础数据类型空间分配

C：
int *p1 = (int *)malloc( sizeof(int) / sizeof(char) );
*p1 = 10;
cout<< *p1 <<endl;
free(p1);
p1 = NULL;

c++:
int *p2 = new int;
*p2 = 12;
cout<< *p2 <<endl;
delete p2;

//使用 new 动态分配的时候，可以直接初始化，int *p2 = new int（5）;但 malloc 不支持这样的用法

2.数组空间的分配

（1）一维数组
C:
int *p1 = (int *)malloc( sizeof(int) / sizeof(char) * 10);
free(p);

C++:
int *p2 = new int[10];  //为数组分配空间时，不能直接初始化
delete []p2;    //如果不加[]，会造成内存泄漏 

（2）二维数组
C：
int (*a)[2] = (int(*)[2])malloc( sizeof(int) * 3 * 2);
free(a); 

C++：
const int a = 5, b = 6;
int **p = new int *[a]; //开辟一维空间
for (int i = 0; i < a; i++) //开辟二维空间
{
    p[i] = new int[b];
}

for (int i = 0; i < a; i++)
{
    delete []p[i];
}
delete []p;

3.动态分配对象

C:
Test *p1 = (Test *)malloc( sizeof(Test ) / sizeof(char));
free(p1);

C++:
Test *p2 = new Test ;
delete p2;
Test *p3 = new Test(10); //会调用一个参数的构造函数

---

类中的静态成员

静态成员函数是类的对象，不是对象的成员，所有对象共享这个参数。
静态成员变量必须在外部，重新定义并初始化；

#include <iostream>
using namespace std;

class Test
{
public:
        // 静态成员函数 只能使用静态成员变量
        static void print()
        {
            //m_a = 10; 编译不通过
            cout << "m_sa = " << m_sa << endl;
        }
public:
    int m_a;
    static int m_sa;
};

int Test::m_sa = 123;

int main()
{
    Test t;
    t.print();   // m_sa = 123;

    t.m_sa = 200;
    Test t2;
    t2.print();  // m_sa = 200;

    //静态成员的两种调用方式
    //1.用对象名去调用
    t2.m_sa = 201;
    cout<< "m_sa = "<< t2.m_sa << endl; // m_sa = 201;

    //2.类名调用
    Test::m_sa = 202;
    cout<< "m_sa = "<< Test::m_sa << endl; // m_sa = 202;
    return 0;
}

---

对象模型

C++中的class从面向对象理论出发，将变量(属性)和函数(方法)集中定义在一起，用于描述现实世界中的类。从计算机的角度，程序依然由数据段和代码段构成。

#include <iostream>

using namespace std;

class Test
{
public:
    Test(int a, int b)
    {
        m_a = a;
        m_b = b;
    }

    // 类的普通成员函数内都有一个隐藏的指针 this,  该指针指向当前操作的对象
    void print ()  // ===> void print (Test *const this) 
    {
        printf ("a = %d, b = %d\n", this->m_a, this->m_b);
    }

    // 静态成员函数内部没有 this 指针，所以无法使用类的普通成员变量
    static void printA ()
    {
        printf ("m_sa = %d\n", m_sa);
    }
private:
    int m_a;
    int m_b;
    static int m_sa;
};

int Test::m_sa = 10;

int main()
{
    Test t(1,2), t1(3, 4), t2(5, 6);

    printf ("sizeof t = %d\n", sizeof(t));

    t.print();
    t1.print();
    t2.print();

    return 0;
}

const 在类的内部使用

class Test
{
public:
    Test(int a, int b)
    {
        this->a = a;
        this->b = b;
    }

    void  print() const  // void print (const Test *const this) 
    {
        //a = 10; 函数（）后的const表示，隐式指向的对象不可修改
        printf("a = %d, b = %d\n", this->a, this->b);
    }
public:
    int a;
    int b;
};

// 类的内部成员函数和全局函数 实现同样的功能  有哪些不一样的地方  
// 全局函数比 类的内部函数 多了一个参数
//void print(const Test &obj),此时无法对obj的成员进行修改
void print(Test &obj)   // Test * const this
{
    //obj.a = 10;
    printf("a = %d, b = %d\n", obj.a, obj.b);
}

int main()
{
    Test t(1, 2);
    t.print();
    print(t);

    return 0;
}

---

友元函数和友元类

要在类的外部使用类中的私有成员，使用友元函数，让全局函数操作类的私有成员变量。
友元函数的声明：在函数原型前加上关键字 friend
注意：
1.友元函数不是类的成员函数，是一个全局函数；
2.友元函数的声明可以放在类的任意位置，public、private、protected 对 friend 声明无效；
3.友元函数破坏了类的封装性，一般不建议使用；
4.友元函数没有 this 指针，因为它是全局函数而不在类的内部。

#include <iostream>

using namespace std;

class Student
{
    friend void printS(Student &s);
private:
    Student(const Student &obj);

public:
    Student (int a, char *name)
    {
        this->age = a;
        this->name = name;
    }

    void printS()
    {
        printf ("age = %d, name = %s\n", age, name);
    }
    void printAddess(Address *addr);
private:
    int age;
    char *name;
};

// 全局函数
void printS(Student &s)
{
    printf ("age = %d, name = %s\n", s.age, s.name);
}

int main()
{
    Student s(10, "小明");
    printS(s);

    return 0;
}

友元类的基本用法与友元函数相同，但要注意谁（x）要访问谁（y），将谁（x）设为谁（y）的友元。

#include <iostream>

using namespace std;

class Address;

class Student
{
    friend void printS(Student &s);
private:
    Student(const Student &obj);

public:
    Student (int a, char *name)
    {
        this->age = a;
        this->name = name;
    }

    void printS()
    {
        printf ("age = %d, name = %s\n", age, name);
    }
    void printAddess(Address *addr); 
    //对于这种在类（Student）中访问其他类（Address）的成员的函数，先在类中做声明，再在Address类后面实现。
private:
    int age;
    char *name;
};

void printS(Student &s)
{
    printf ("age = %d, name = %s\n", s.age, s.name);
}

class Address
{
    // A 类如果是 B 类的友元类，则 A 类的所有成员函数都是 B 类的友元函数
    friend Student;
public:
    Address(char *s, char *c, char *x):shen(s), city(c), xian(x)
    {

    }
private:
    char *shen;
    char *city;
    char *xian;
};

//使用域解析符限注明该函数是Student类的成员函数
void Student::printAddess(Address *addr)
{
    printf("省： %s, 市：%s, 县：%s\n", addr->shen, addr->city, addr->xian);
}

int main()
{
    Student s(10, "小明");
    printS(s);

    Address *addr = new Address("江苏", "南京", "江宁");
    s.printAddess(addr);
    delete addr;

    return 0;
}