C++系列笔记（四）

墨明棋妙27

发布于 2022-08-24 15:23:16

5960

文章被收录于专栏：19961996

【导读】《21天学通C++》这本书通过大量精小短悍的程序详细而全面的阐述了C++的基本概念和技术，包括管理输入/输出、循环和数组、面向对象编程、模板、使用标准模板库以及创建C++应用程序等。这些内容被组织成结构合理、联系紧密的章节，每章都可在1小时内阅读完毕，都提供了示例程序清单，并辅以示例输出和代码分析，以阐述该章介绍的主题。本文是系列笔记的第四篇，欢迎各位阅读指正！

参数是引用，如果不加&的话就是平常参数，也就是传值参数。传值参数，如果实参在函数中被修改时，外面的这个变量并不会改变。引用参数，也就是在形参加上&，如果实参在函数中被修改的同时，外面的这个变量也会被修改。例：

int a=10;
void add1(int x)
{
    x++;
}
add1(a);

执行完之后a还是10。

int a=10;
void add2(int &x)
{
    x++;
}
add2(a);

执行完之后a=11。 禁止在栈中实例化的类

数据库类把析构函数设置为私有，只能使用new在自由储存区中创建其对象。如下代码：

class MonsterDB
{
private:
    ~MonsterDB( ) {};
public:
    static void DestroyInstance(MonsterDB* pInstance)
    {
        delete pInstance;
    }
    //……imagine a few other methods
};
int main()
{
    MonsterDB* pMyDatabase = new MonsterDB();
    MonsterDB :: DestroyInstance(pMyDatabase);
    return 0;
}

this指针 在类中，关键字this包含当前对象的地址，换句话说，其值为&object。 结构不同于类的地方 关键字struct来自于c语言，它与类极其相似。除非指定了，结构中的成员默认为公有，而类默认为私有；结构默认以公有方式继承，而类默认以私有方式继承。 声明友元函数 不能从外部访问类的私有数据成员和方法，但这条规则不适用于友元类和友元函数。要声明友元类和友元函数，可使用关键字friend，如下述所示。

#include<iostream>
#include<string>
using namespace std;
class Human
{
private:
        string Name;
        int Age;
        friend void DisplayAge(const Human& Person);
public:
        Human(string InputName, int InputAge)
        {
               Name = InputAge;
               Age = InputAge;
        }
};
void DisplayAge(const Human& person)
{
        cout << person.Age << endl;
}
int main()
{
        Human FirstMan("Adam", 25);
        cout << "Accessing private member age via:";
        DisplayAge(FirstMan);
        return 0;
}

输出为：

Accessing private member age via:25

与函数一样，也可以将外部类指定为可信任的朋友。

friend class Utility;
class Utility
{
    //code here;
}

实现继承 基类比如鸟，将定义鸟的基本属性，如有羽毛和翅膀等等；派生类为乌鸦、鹦鹉等等将继承这些属性并进行定制。有些派生类能继承两个基类，这种称为多继承。 C++派生语法

//declaring a super class
class Base
{
    //……base class members
};
//declaring a sub_class
class Derived: acess-specifier Base
{
    //……derived class members
};

其中acess-specifier可以是public（这是最常见的，表示派生类是一个基类）、private或protected（表示派生类有一个基类）。示例代码：

#include<iostream>
#include<string>
using namespace std;
class Fish
{
public:
        bool FreshWaterFish;
        void Swim()
        {
               if (FreshWaterFish)
                       cout << "swims in lake" << endl;
               else
                       cout << "swims in sea" << endl;
        }
};
class Tuna :public Fish
{
public:
        Tuna()
        {
               FreshWaterFish = false;
        }
};
class Carp :public Fish
{
public:
        Carp()
        {
               FreshWaterFish = true;
        }
};
int main()
{
        Carp myLunch;
        Tuna myDinner;
        cout << "my food to swim" << endl;
        cout << "lunch:";
        myLunch.Swim();
        cout << "Dinner:";
        myDinner.Swim();
        return 0;
}

输出为：

my food to swim
lunch:swims in lake
Dinner:swims in sea

访问限定符protected 将属性声明为protected时，相当于允许派生类和友元类访问他，但禁止在继承层次结构外部（包括main（）访问他）。

class Fish
{
protected:
    bool FreshWaterFish;
    //code here
}

基类初始化——向基类传递参数。如下面代码所示：

class Base
{
public:
    Base(int SomeNumber)  //overload constructor
    {
        //Do Something with Somenumber
    }
};
class Derived : public Base
{
public:
Derived(): Base(25)  //instance class Base with argument 25
{
    //derived class constructor code
}
};

上述代码改一下：

//基类改一下
public :
    Fish(bool IsFreshWater) : FreshWaterFish(IsFreshWater) {}
//继承类Tuna改一下
public:
    Tuna() : Fish(false) {}
//继承类Carp改一下
public:
    Carp() : Fish(true) {}

在派生类中覆盖基类的方法 如果派生类实现了从基类继承的函数，且返回值和特征值相同，就相当于覆盖了基类的方法，即派生类有一个和基类一模一样的函数，则程序运行是输出了派生类的函数结果。 调用基类中被覆盖的方法 1)如果要在main（）中调用Fish::Swim(),需要使用作用域解析符（：：）把上述的代码改一下就可以。

//在Carp类中
void Swim()
{
    cout<<"Carp swims is too low"<<endl;
    Fish::Swim();
}
//在main（）函数中
cout<<"Dinner:";
myDinner.Fish::Swim();

2)在Carp类中，使用关键字using解除对Fish::Swim()的隐藏

//在Carp类中
class Carp
{
public:
    using Fish::Swim;  //去除基类隐藏的方法
}

3）在Carp类中，覆盖Fish::Swim()的所有重载版本。 析构顺序和构造顺序

继承时，构造函数和析构函数的调用顺序 1、先调用父类的构造函数，再初始化成员，最后调用自己的构造函数 2、先调用自己的析构函数，再析构成员，最后调用父类的析构函数 3、如果父类定义了有参数的构造函数，则自己也必须自定义带参数的构造函数 4、父类的构造函数必须是参数列表形式的 5、多继承时，class D: public Base2, Base1, Base的含义是：class D: public Base2, private Base1, private Base，而不是class D: publicBase2, public Base1, public Base6.多继承时，调用顺序取决于class D: public Base2, public Base1, public Base的顺序，也就是先调用Base2,再Base1，再Base。但是有虚继承的时候，虚继承的构造函数是最优先被调用的。 私有继承：private 即便是Base类的公有成员和方法，也只能被Derived类使用，而无法通过Derived实例来使用他们。 保护继承：protected 保护继承与私有继承的相似之处：1）他也表示has-a关系 2）他也让派生类能够访问基类的所有公类和保护成员 3）在继承结构层次外面，也不能通过派生类实例访问基类的公有成员随着继承结构的加深，保护继承与私有继承有些不同

class Derived2:protected Derived
{
    //can acess menber of Base
};

在保护继承层次结构中，子类的子类（Derived）能够访问Base类的公有成员。将Base类作为子类的私有成员被称为组合或聚合，如下面代码所示：

class Car
{
private:
    Motor heartOfcar;
public:
void Move()
{
    heartOfca.SwitchInginition();
    //code here;
]
];

这能够轻松在Car类中添加Motor成员而无需改变继承结构层次 切除问题

Derived objectDerived;
Base objectBase = objectDerived;

或者：

void FunuseBase(Base Input)
……
Derived objectDerived;
FunuseBase(objectDerived);

上述代码都将Derived对象复制给Base对象，一个是显示复制，一个是通过传递函数。在这种情况下，编译器将只会复制objectDerived的Base部分，即不是整个对象，而是Base能容纳的部分。这种无意间裁剪数据，导致Derived变成Base的行为称为切除（slice） 多继承 C++允许继承多个基类

class Derived : acess-specifier Base1,cess-specifier Base2,……
{
    //class menbers
};

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2019-11-23，如有侵权请联系 cloudcommunity@tencent.com 删除

面向对象编程

c++

本文分享自计算机视觉CV 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

面向对象编程

c++

登录后参与评论

0 条评论

热度

C++系列笔记（四）

C++系列笔记（四）

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐