C++基础③new对象，继承，友元函数，函数的可变参数

接续上篇C++基础②构造函数，析构函数，拷贝构造函数

前言

C++是一门面向对象的编程语言 ， 创建用以创建对象 ， 则不在话下 ， 我们知道，Java在创建对象的时候需要使用关键字new (忽略反射)， 而在C++中创建对象可以使用new也可以不使用 ， 那么使用new和不使用 ， 有什么区别呢 ？ 答案是：对象存储的内存空间不一样 ， 不使用new关键字创建的对象，对象数据存储在栈内存空间里面 ， 使用new关键字 ， 则会将对象数据存储在堆内存空间 。

我们知道 ， 栈内存空间是固定有限的 ， 所有对象数据很大很多的话 ， 就需要存储在堆内存空间 ， 不然可能会造成栈溢出 。

new 一个对象

使用new关键字创建对象 ， 写法和Java一样 ， Music* m = new Music("决口不提！爱你","郑中基"); ， 就连对象存储的内存空间都是一样的 ， Java对象与C++ new出来的对象 ， 都是存储在堆内存空间 。有点区别的是 ， 使用new创建的C++对象 ， 需要使用delete来回收对象开辟的内存空间 ， 如果使用free函数回收开辟的内存空间，则对象执行完不会执行析构函数。

using namespace std;

class Songstr {
private:
    char* name;

public:
    Songstr(char* name) {
        this->name = name;
        cout << "Songstr构造函数" << endl;
    }

    char* getName() {
        return this->name;
    }

    ~Songstr()
    {
        cout << "Songstr析构函数" << endl;
    }
};

class Music {
private:
    char* musicName;
    // 如果类中存在对象字段，而这个对象需要传入构造函数参数，则需要在当前类构造函数)后面：进行赋值初始化
    // Music(char* musicName,char* songstrName) : s(songstrName)
    Songstr s;

public:
    Music(char* musicName,char* songstrName) : s(songstrName) {
        this->musicName = musicName;
        cout << "Music构造函数" << endl;
    }

    void printInfo() {
        cout << "歌曲： " << this->musicName << endl;
        cout << "歌手： " << this->s.getName() << endl;
    }

    ~Music()
    {
        cout << "Music析构函数" << endl;
    }
};


/*使用new关键字创建对象*/
void useNewKeyCreateObject() {
    // 使用new关键创建对象 ， 则会在堆内存中创建一个空间来存储对象数据
    // 需要使用delete关键字来回收堆内存中的内存空间 ， 也可以使用free
    // 使用free则不会出发析构函数
    Music* m = new Music("决口不提！爱你","郑中基");
    m->printInfo();

    // 回收为对象开辟的空间
    delete m;

    //// new一个数组
    //int* arr = new int[];

    //// 回收数组空间
    //delete[] arr;
}

继承

C++的基础方式和Java不同， C++可以多继承， 一个类可以继承多个类 ， 而对于父类构造函数的赋值也不一样 。C++的基础符号是 :以冒号作为继承符号class Rose : public Flower ， 在继承的时候最好明确继承权限(可不写继承权限，默认public)

继承权限列表：

基类	继承权限	子类
public	public继承	public
public	protected继承	protected
public	private继承	private
protected	public继承	protected
protected	protected继承	protected
protected	private继承	private
private	public继承	子类无权访问
private	protected继承	子类无权访问

using namespace std;

class Flower {

protected:
    int id;
    char* name;

public:
    Flower(int id, char* name) {
        this->id = id;
        this->name = name;
    }

    void printInfo() {
        cout << "id = " << this->id << "    name = " << this->name << endl;
    }
};


/*
    CPP 可以进行多继承 ， 继承父类的的构造函数按照如下编写 ， 也可直接传入默认值
*/
class Rose : public Flower {

public:
    /*子类继承父类，父类有构造函数，需要子类传入，则在构造函数后面使用:父类名(传入参数)*/
    Rose(int id, char*name) : Flower(id, name) {

    }

    void printInfo() {
        cout << "id = " << this->id << "    name = " << name << " -- "<< endl;
    }
};

因为C++是多继承的特性 ， 所有就会造成继承的二义性，所以我们需要使用虚继承来解决同名成员不明确的问题 。

//继承的二义性
//虚继承，不同路径继承来的同名成员只有一份拷贝，解决不明确的问题
/*
class A{
public:
    char* name;
};

class A1 : virtual public A{
    
};

class A2 : virtual public A{

};

class B : public A1, public A2{

};

void main(){
    B b;    
    b.name = "zeno";
    //指定父类显示调用
    //b.A1::name = "zeno";
    //b.A2::name = "zeno";
    system("pause");
}

Tips：虚继承 ， 在继承父类的时候使用virtual关键字修饰 ， 这个关键字， 后续还会遇到很多次

友元函数

如果在Java中，子类想访问父类的私有成员，除非使用反射机制，不然那是不可能的 。但在C++中 ，想要访问父类的私有成员 ， 那就轻松很多了 。我们只需要在父类中，声明子类是父类的友元类 ， 那么就可以在之类访问修改父类的私有成员了。

/*
    friend function demo

    // 友元函数可以访问一个类的任何字段和函数
*/

#include <iostream>

using namespace std;

class FriendFunction {

    // 创建一个友元函数 ， 用来访问私有字段 ， 需要在外部实现函数
    friend void accessFriendFunctionFeild(FriendFunction *p, int id, char* name);

    // 友元类 ， 友元类可以访问此类任意字段和函数
    friend class FriendClass;

// 类私有字段 , 私有字段，常规访问需要创建public get的访问函数 , 不能进行直接访问
private:
    int id;
    char* name;


public:
    FriendFunction(int id, char* name) {
        this->id = id;
        this->name = name;
    }

    void printfInfo() {
        cout << "id = " << this->id << "   name = " << this->name << endl;
    }

};

/*作为类的友元类，可以修改类中任意字段与函数*/
class FriendClass {

private:
    FriendFunction *f;

public:
    FriendClass(FriendFunction *f) {
        this->f = f;
    }

    void accessFriendFeild() {
        f->id = 100;
        f->name = "友元类修改";
    }

};

不管是友元类还是友元函数 ， 只要在类中声明 ， 那么此类相当于他们就没有秘密了，友元类和友元函数，可以任意访问此类的私有成员。需要注意的是，友元函数需要在类的外部实现 。

使用友元函数，友元类

/*友元函数实现 用来访问私有字段*/
void accessFriendFunctionFeild(FriendFunction *p, int id, char* name) {
    p->id = id;
    p->name = name;
}

/*友元函数使用*/
void useFriendFunction() {

    FriendFunction *f = new FriendFunction(1, "找不到你的方向");
    f->printfInfo();

    accessFriendFunctionFeild(f, 3, "我是你的眼");
    f->printfInfo();

    /*java中的Class对象，可以访问任意对象的任意字段，本质是Class类每个类的友元类*/
    FriendClass fc(f);
    fc.accessFriendFeild();
    f->printfInfo();
}

函数可变参数

函数的可变参数，在Android很常见，比如我们经常使用的AsyncTask 。在C++也有函数的可变参数 ，常见于Android LOG函数。

/*
    CPP 可变参数
*/

#include <stdarg.h>
#include <iostream>

using namespace std;

class VariableParameter
{
public:

    /*可变参数*/
    void VariableParameter::variableParams(int i, ...)
    {
        // 可变参数列表
        va_list ap_list;
        // 从...之前的第一个参数开始，后面就是可变参数
        va_start(ap_list, i);
        // 得到可变参数 ， 参数①可变参数列表  ， 参数②参数类型。
        int age = va_arg(ap_list, int);
        double weight = va_arg(ap_list, double);
        char* registry = va_arg(ap_list, char*);
        va_end(ap_list);

        cout << "编号: " << i << " 年龄： " << age << " 体重： " << weight << "  籍贯： " << registry << endl;
    }

};

使用可变参数

/*函数可变参数*/
void useVariableParameter() {
    VariableParameter v;
    v.variableParams(1, 20,100.2,"湖南");
}

Tips：C++的可变参数，必须含有一个固定参数，可变参数类型不固定，可以是任意数据类型，通过va_arg()函数指定数据类型 。

结语

C++与Java有很多相似的地方，学习起来 ， 应该没那么晦涩难懂， 只是有些语法上的差别，和一些特殊的用法 。作为Android程序员学C++，不一定要去成天写C++，但至少要能看懂，要能修改 ， 我们的主要目的就是用成熟的C/C++库 ， 编写小模块的C/C++程序 。

源码

Hello_CPP