C++初阶——权限与继承

 

目录

一、C++权限方面的问题

1.访问权限

2.继承机制

二、C++const引用

const引用有以下几个特点

临时对象引用

常量引用成员变量

 二、c++引用空间相关问题

三.auto

---

 

一、C++权限方面的问题

【C++入门】访问权限管控和继承机制详解_权限继承功能-CSDN博客文章浏览阅读840次。(2)但是在派生类还是可以调用基类的同名成员的，可以使用指定域名的方法：父类::成员；显示的指定要调用父类的成员而不是派生类的成员；_权限继承功能https://blog.csdn.net/weixin_42031299/article/details/127342114

C++ 中的访问权限（Access Specifiers）管控和继承机制是面向对象编程的重要概念之一。通过访问权限和继承，可以控制类成员的可见性和访问级别。

1.访问权限

1. C++ 提供了三种访问权限：公有（public）、私有（private）和保护（protected）。它们用于限制类成员的可见性和访问级别。

2. 默认情况下，类的成员是私有的。我们可以使用访问权限来控制哪些成员对外部可见，哪些成员对外部隐藏。

   例如：

   • 公有（public）：公有成员在类的内部和外部都是可见的，可以被任何代码访问。
   • 私有（private）：私有成员只能在类的内部访问，外部无法直接访问私有成员。
   • 保护（protected）：保护成员在类的内部和子类中可见，但在外部不可直接访问。

• class MyClass {
  public:
      int publicVar;    // 公有成员变量
      void publicFunc();    // 公有成员函数
  
  private:
      int privateVar;   // 私有成员变量
      void privateFunc();   // 私有成员函数
  
  protected:
      int protectedVar;   // 保护成员变量
      void protectedFunc();   // 保护成员函数
  };
  

2.继承机制

• C++ 中的继承机制允许一个类（称为派生类或子类）从另一个类（称为基类或父类）继承属性和行为。

  继承可以通过关键字 class 或 struct 来定义。

  例如：

  • 公有继承（public inheritance）：派生类继承了基类的公有成员和保护成员，但私有成员不可直接访问。
  • 私有继承（private inheritance）：派生类继承了基类的公有成员和保护成员，但都变为私有成员。
  • 保护继承（protected inheritance）：派生类继承了基类的公有成员和保护成员，但都变为保护成员。

1. // 基类
   class BaseClass {
   public:
       int publicVar;
       void publicFunc();
   
   private:
       int privateVar;
       void privateFunc();
   
   protected:
       int protectedVar;
       void protectedFunc();
   };
   
   // 公有继承
   class DerivedClass : public BaseClass {
       // DerivedClass 可以访问 BaseClass 的公有成员和保护成员
   };
   
   // 私有继承
   class DerivedClass : private BaseClass {
       // DerivedClass 可以访问 BaseClass 的公有成员和保护成员，但都变为私有成员
   };
   
   // 保护继承
   class DerivedClass : protected BaseClass {
       // DerivedClass 可以访问 BaseClass 的公有成员和保护成员，但都变为保护成员
   };
   

   通过继承，派生类可以获得基类的属性和行为，并且可以在派生类中添加新的成员或修改继承的成员。

二、C++const引用

在C++中，const引用是指对常量进行引用的一种方式。通过使用const修饰符来声明引用，可以确保被引用对象在引用期间不会被修改。

const引用有以下几个特点

对常量引用：const引用主要用于传递常量参数给函数，防止函数内部对参数进行修改。例如：

void printValue(const int& value) {
    // value是一个const引用，不能在函数内部修改它
    cout << "Value: " << value << endl;
}

临时对象引用

const引用还可以绑定到临时对象（即右值）上。这种用法可以避免在使用临时对象时进行不必要的拷贝构造。例如：

const int& result = getSum(3, 4);

常量引用成员变量

在类中，可以使用const引用作为成员变量的类型，以确保该成员变量在对象的整个生命周期内都不能被修改。例如：

class MyClass {
private:
    const int& constantRef;
public:
    MyClass(const int& value) : constantRef(value) {}
};

需要注意的是，const引用只能绑定到具有相同或更长生命周期的对象上，而不能绑定到临时对象的非const引用或非const指针上。

 二、c++引用空间相关问题

在 C++ 中，引用不开辟空间。引用不是一个对象，它只是已存在的变量或对象的别名。引用本身不占用内存，它只是一个已存在对象的别名或昵称。引用变量在内存中只是原变量的另一个名称，所以对引用变量的任何操作都会影响到原变量。

因为引用只是一个别名，所以我们在创建引用时必须将其初始化成一个已经存在的对象，否则会导致编译错误。同时，在使用引用时也要注意，如果被引用的对象被销毁或释放了，那么该引用就会成为悬空引用（dangling reference），访问它会引发未定义行为的错误。因此，我们应该始终确保引用指向的对象在引用生命周期内都是有效的。

需要注意的是，引用和指针虽然有相似之处，但二者之间存在一些重要的区别。指针是一个实际的对象，它存储了一个地址值，指向一个具体的内存位置，而引用只是一个别名，没有实际的对象来支持它。因此，我们可以对指针进行运算、赋值等操作，而对于引用则不能进行这些操作。

总之，在 C++ 中，引用不开辟空间，它只是一个已存在对象的别名或昵称，对引用进行的任何操作都会直接影响到原变量。

 

当我们创建一个引用时，它必须初始化为一个已经存在的对象或变量。下面是一些关于引用的示例：

int main() {
    int num = 10;
  
    // 创建一个整型引用，并将其初始化为num
    int& ref = num;
    
    // 修改引用的值会直接修改原变量的值
    ref = 20;
    std::cout << "num: " << num << std::endl;  // 输出：num: 20
  
    // 创建一个常量引用，它不能修改被引用的对象的值
    const int& constRef = num;
    // constRef = 30;  // 错误，不能修改常量引用
    
    // 引用作为函数参数，可以方便地传递和修改变量的值
    void increment(int& value) {
        value++;
    }
  
    int value = 5;
    increment(value);
    std::cout << "value after increment: " << value << std::endl;  // 输出：value after increment: 6
  
    return 0;
}

在上面的示例中，我们创建了一个整型变量 num 和一个与之关联的引用 ref。通过修改 ref 的值，我们实际上修改了 num 的值。

另外，我们还创建了一个常量引用 constRef，它不能修改被引用的对象的值。

最后，我们定义了一个函数 increment，它以引用作为参数。这使得我们可以直接修改传递给函数的变量的值，而无需使用指针或返回值。

这些示例展示了引用在C++中的使用方式，它们提供了一种方便而灵活的方式来操作和传递变量。

 

三.auto

在 C++11 标准中，引入了 auto 关键字，用于自动推导变量的类型。auto 关键字可以使代码更简洁、可读性更高，并且可以轻松地处理复杂的类型声明。

auto 关键字的使用方法如下：

auto 变量名 = 表达式;

在这里，变量名是我们要定义的变量的名称，表达式是一个用于初始化变量的表达式。auto 关键字会根据表达式的类型来推断变量的类型，从而省略了我们手动指定类型的步骤。

例如，我们可以使用 auto 来推导一个整数类型的变量：

auto i = 42;  // 推导为 int 类型

我们还可以使用 auto 来推导一个 std::vector 类型的变量：

std::vector v = {1, 2, 3};
auto vec = v;  // 推导为 std::vector 类型

auto 关键字的好处在于，我们不必手动指定变量类型，这样可以简化代码并提高可读性。此外，auto 还可以处理一些比较复杂的类型声明，例如函数指针和 lambda 表达式等。这些类型声明通常会很冗长，使用 auto 可以避免这种情况。

需要注意的是，auto 关键字不能用于函数参数、类成员变量、非静态局部变量等场景。此外，在使用 auto 推导变量类型时，要注意表达式的类型，以避免类型推导错误。