C++学习笔记——类继承

class Animal {
protected:
    std::string name;
    int age;

public:
    Animal(const std::string& _name, int _age) : name(_name), age(_age) {}

    void eat() {
        std::cout << name << " is eating." << std::endl;
    }

    void sleep() {
        std::cout << name << " is sleeping." << std::endl;
    }

    virtual void sound() {
        std::cout << name << " makes a sound." << std::endl;
    }
};

在这个示例中，它具有以下特点：

`2.2 Animal`是一个基类。

表示动物

数据成员：name表示动物的名字，age表示动物的年龄。这些成员被声明为protected，可以被派生类访问。
构造函数：构造函数用于初始化动物的名字和年龄。
成员函数：eat()和sleep()是普通成员函数，表示动物的吃和睡觉行为。
虚函数：sound()是一个虚函数，表示动物发出声音的行为。它被声明为虚函数，以便派生类可以覆盖该函数来实现自己特定的声音行为。

使用这个基类，你可以创建派生类来表示不同种类的动物，例如狗、猫、鸟等。派生类可以继承基类的成员函数和数据成员，并可以添加自己特定的成员函数和数据成员。

基类允许你通过多态性的概念，以相同的方式对待不同类型的对象。例如，你可以使用基类指针或引用来操作派生类的对象，从而实现代码的灵活性和可扩展性。

这个简单的基类示例展示了面向对象编程中的封装、继承和多态的概念。通过基类和派生类的组合，可以实现代码的重用和结构化。

三、继承

3.1概念

是面向对象编程中的一种重要概念，它允许一个类（称为派生类或子类）从另一个类（称为基类或父类）继承属性和行为。

通过继承，派生类可以获得基类的成员函数和数据成员，并可以在其基础上添加自己特定的功能。这样可以实现代码的重用，减少了冗余的代码编写。

在C++中，继承有三种方式：

公有继承（public inheritance）：使用public关键字，派生类将继承基类的公有成员和保护成员。公有继承表示派生类与基类之间存在"是一个"的关系，派生类的对象可以被视为基类的对象。

保护继承（protected inheritance）：使用protected关键字，派生类将继承基类的保护成员，并将其作为自己的保护成员。保护继承表示派生类与基类之间存在一种特殊的关系，派生类的对象不能被视为基类的对象。

私有继承（private inheritance）：使用private关键字，派生类将继承基类的私有成员，并将其作为自己的私有成员。私有继承表示派生类与基类之间存在一种实现细节的关系，派生类的对象不能被视为基类的对象。

继承提供了一种机制，通过定义一个通用的基类，使得派生类可以继承这些通用特性，并根据需要进行修改和扩展。在继承关系中，基类通常包含了派生类共有的特征和行为，而派生类则添加了自己特定的特征和行为。

需要注意的是，派生类可以通过重写（覆盖）基类的成员函数来改变其行为，这是通过使用virtual关键字和虚函数实现的。此外，C++支持多重继承，允许一个派生类从多个基类继承属性和行为。

在面向对象编程中，is-a关系是一种重要的概念，用于描述一个类是否属于另一个类的一种特殊情况，通常也称为继承关系。

3.2is-a关系

表示一个类是另一个类的一种类型或子类，即派生类是基类的一种特例。例如，狗是一种动物，所以Dog类是Animal类的子类，可以使用公有继承实现。

is-a关系通常表示为"派生类 is a 基类"的形式。在C++中，使用公有继承可以实现is-a关系，因为派生类将继承基类的公有成员和保护成员，可以像基类一样使用这些成员。

例如：

// 定义一个基类Animal
class Animal {
public:
    void eat();
    void sleep();
};

// 定义一个派生类Dog，它是Animal的子类
class Dog : public Animal {
public:
    void bark();
};

在上面的例子中，Dog类是Animal类的子类，因此可以使用Dog对象调用eat()和sleep()函数，这就体现了is-a关系。

is-a关系是面向对象编程中最基本的关系之一，它反映了现实世界中的分类关系。通过定义一个通用的基类，我们可以将代码组织成层次结构，实现代码的重用和结构化。

?3.3多态公有继承

多态是面向对象编程中的一种重要概念，它允许一个对象在不同的情况下表现出不同的行为，是面向对象程序设计中最重要的特性之一。

公有继承可以提供多态的实现方式之一，这种多态称为动态多态（或运行时多态）。简单来说，动态多态指的是在运行时根据对象的实际类型来调用相应的函数。

在C++中，使用虚函数实现动态多态。虚函数是一种特殊的成员函数，它通过关键字virtual进行声明，并且在派生类中可以被重写。当基类的指针或引用指向派生类的对象时，可以通过虚函数实现动态多态。

例如：

// 定义一个基类Animal
class Animal {
public:
    virtual void makeSound();
};

// 定义一个派生类Dog，它重写了基类的makeSound()函数
class Dog : public Animal {
public:
    void makeSound() override;
};

// 定义一个派生类Cat，它重写了基类的makeSound()函数
class Cat : public Animal {
public:
    void makeSound() override;
};

在上面的例子中，Animal类定义了虚函数makeSound()，Dog和Cat类分别重写了这个函数。当基类指针或引用指向Dog或Cat对象时，可以通过调用makeSound()函数来实现动态多态。

例如：s

Animal* animal = new Dog;
animal->makeSound(); // 调用Dog类的makeSound()函数

animal = new Cat;
animal->makeSound(); // 调用Cat类的makeSound()函数

在上面的例子中，animal指针先指向Dog对象，然后调用makeSound()函数时会调用Dog类的makeSound()函数；之后animal指针又指向Cat对象，调用makeSound()函数时会调用Cat类的makeSound()函数。这就体现了动态多态的特性。

总之，通过公有继承和虚函数，C++提供了一种强大的多态机制，可以使代码更加灵活和易于扩展。

?3.4静态联编和动态联编

静态联编（静态绑定）和动态联编（动态绑定）是面向对象编程中两种不同的函数调用机制。

静态联编（静态绑定）：静态联编是指在编译时确定调用哪个函数的机制，也称为早期绑定。在静态联编中，函数调用的解析是基于变量的静态类型（编译时类型）进行的。编译器会根据变量的声明类型来决定调用哪个函数，并且这个决定是在编译阶段确定的。

静态联编适用于非虚函数和静态函数。由于在编译时确定了函数的调用，因此静态联编具有较高的执行效率，但缺少灵活性和多态性。

动态联编（动态绑定）：动态联编是指在运行时确定调用哪个函数的机制，也称为晚期绑定。在动态联编中，函数调用的解析是基于变量的实际类型（运行时类型）进行的。编译器会根据对象的实际类型来决定调用哪个函数，这个决定是在运行时确定的。

动态联编适用于虚函数。通过使用虚函数和基类指针或引用，可以实现在运行时根据对象的实际类型来调用相应的函数，实现多态性。动态联编提供了更高的灵活性和可扩展性，但在运行时需要额外的开销。

总结：

静态联编是在编译时确定函数调用的机制，适用于非虚函数和静态函数，执行效率较高。
动态联编是在运行时确定函数调用的机制，适用于虚函数，可以实现多态性，具有更高的灵活性和可扩展性，但在运行时需要额外开销。

#include <iostream>

// 基类 Animal
class Animal {
public:
    void makeSound() {
        std::cout << "Animal makes a sound." << std::endl;
    }
};

// 派生类 Dog
class Dog : public Animal {
public:
    void makeSound() {
        std::cout << "Dog barks." << std::endl;
    }
};

// 派生类 Cat
class Cat : public Animal {
public:
    void makeSound() {
        std::cout << "Cat meows." << std::endl;
    }
};

int main() {
    Animal animal;
    Dog dog;
    Cat cat;

    // 静态联编 - 根据变量的静态类型调用函数
    animal.makeSound();  // 输出: Animal makes a sound.
    dog.makeSound();     // 输出: Dog barks.
    cat.makeSound();     // 输出: Cat meows.

    // 动态联编 - 使用指针或引用调用虚函数
    Animal* animalPtr1 = &animal;
    Animal* animalPtr2 = &dog;
    Animal* animalPtr3 = &cat;

    animalPtr1->makeSound(); // 输出: Animal makes a sound.
    animalPtr2->makeSound(); // 输出: Dog barks.
    animalPtr3->makeSound(); // 输出: Cat meows.

    return 0;
}

在上述示例中，我们定义了一个基类 Animal 和两个派生类 Dog 和 Cat。Animal 类中的 makeSound 函数并非虚函数，因此在静态联编中，无论使用基类对象还是派生类对象调用该函数，都会调用基类的实现。

然而，当我们使用基类指针或引用指向派生类的对象时，通过动态联编（虚函数）来调用 makeSound 函数时，将根据对象的实际类型来确定应该调用哪个类的实现。这样，我们可以实现多态性，即相同的函数调用可以根据对象的实际类型产生不同的行为。

3.5访问控制

是面向对象编程中的一个重要概念，用于限制类成员的访问权限。通过访问控制，我们可以控制哪些部分的代码可以访问类的成员变量和成员函数，以确保数据的封装性和安全性。

在大多数面向对象编程语言中，通常有以下几种访问控制修饰符：

公有（Public）：公有成员可以在任何地方被访问，包括类的内部和外部。其他类和对象都可以直接访问公有成员。

私有（Private）：私有成员只能在类的内部被访问，其他类和对象无法直接访问私有成员。私有成员通常用于实现类的内部逻辑和数据隐藏。

保护（Protected）：保护成员可以在类的内部和派生类中被访问。派生类中的成员函数可以访问基类的保护成员，但其他类和对象无法直接访问保护成员。

不同的编程语言可能使用不同的关键字来表示这些访问控制修饰符，例如：

C++ 中使用 public、private 和 protected 关键字。
Java 中使用 public、private 和 protected 关键字。
Python 中使用命名约定（例如 _ 前缀）来表示私有成员，而没有严格的访问控制修饰符。

下面是一个 C++ 的示例代码，演示了访问控制的用法：

#include <iostream>

class MyClass {
public:    // 公有成员
    int publicVar;

    void publicMethod() {
        std::cout << "This is a public method." << std::endl;
    }

private:   // 私有成员
    int privateVar;

    void privateMethod() {
        std::cout << "This is a private method." << std::endl;
    }

protected: // 保护成员
    int protectedVar;

    void protectedMethod() {
        std::cout << "This is a protected method." << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.publicVar = 10;     // 可以直接访问公有成员变量
    obj.publicMethod();     // 可以直接调用公有成员函数

    // 下面的语句将导致编译错误，因为私有成员和保护成员无法在外部访问
    // obj.privateVar = 20; 
    // obj.privateMethod();
    // obj.protectedVar = 30; 
    // obj.protectedMethod();

    return 0;
}

在上述示例中，我们定义了一个类 MyClass，其中包含公有、私有和保护成员。在 main 函数中，我们可以直接访问和调用公有成员，但无法访问私有和保护成员。

这种访问控制机制可以帮助我们保护类的内部实现细节，封装数据并提供统一的接口。通过对成员的合理访问控制，我们可以提高代码的安全性、可维护性和可扩展性。

3.6ABC理念

ABC理念是一种管理思想，是Activity-Based Costing（基于活动成本核算）的缩写，有时也被称为Activity-Based Management（基于活动管理）。它在20世纪80年代末由哈佛商学院教授Robert S. Kaplan和Robin Cooper提出，旨在帮助企业更精确地计算成本和经营绩效，以优化产品和服务的设计、生产和销售过程。

ABC理念认为，企业的成本不仅取决于直接材料、直接人工和制造费用等传统成本指标，还受到活动成本的影响。活动成本是指生产或提供产品和服务所需的所有活动和资源的成本，包括设备、人力、能源、时间等。ABC理念通过对活动进行分析和定价，将成本更准确地分配到各个产品、服务或客户上，以便更好地评估其贡献度和盈利能力。

ABC理念的主要思想可以概括为以下几点：

强调活动的重要性：企业的成本和绩效不仅取决于产品和服务本身，还受到生产和销售过程中的各种活动的影响。因此，要准确计算成本和评估绩效，就需要先详细了解和分析这些活动。

区分成本驱动因素：ABC理念认为，不同的活动对成本的贡献程度不同。通过区分成本驱动因素（也就是导致各项活动发生的原因），可以更好地了解成本结构和优化资源配置。

精细计算成本：ABC理念强调将成本精细化到各个活动和产品/服务上，以便更准确地定价和分配成本。这可以帮助企业更好地了解各种产品和服务的盈利能力，并且优化产品和服务的设计、制造和销售过程。

以客户为中心：ABC理念认为，客户是企业最重要的资产。因此，在分析成本和评估绩效时，要以客户为中心，关注他们的需求和反馈，并根据客户的需求来制定产品和服务的设计、生产和销售策略。

ABC理念在管理实践中得到了广泛应用，特别是在制造业和服务业中。它的主要优点包括：

更准确地计算成本和评估绩效，有助于优化资源配置和提高盈利能力。

帮助企业更好地理解产品和服务的盈利能力，以便优化产品和服务的设计、制造和销售过程。

强调客户需求和反馈，有助于提高客户满意度和忠诚度。

促进内部控制和管理流程的优化，有助于提高企业效率和效益。

ABC理念也存在一些挑战和限制。例如，实施ABC理念需要大量的数据收集和分析工作，对企业的信息系统和人力资源提出了较高的要求。此外，ABC理念也可能导致某些活动过度成本化，从而影响企业的有效性和效率。因此，在实施ABC理念时需要慎重考虑，并结合实际情况进行适当的调整和优化。

文章来源:https://blog.csdn.net/m0_62338174/article/details/135516296
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！