cpp学习笔记4

using的用法。

using namespace std;说明std库里的所有名称都不用再声明std::就可以直接使用，但是这容易导致命名冲突，因为你可能不小心创建了一个和std库同名的函数。

​​using std::cout；说明只在使用cout时不用声明是std库的。

using Int = int;  Int x = 10;

关于继承

class Animal {          // 基类
private:
    int m = 10;
public:
    void eat() {
        std::cout << "Animal is eating " <<m<< std::endl;
    }
};

class Dog : public Animal {  // 派生类
public:
    void bark() {
        std::cout << "Dog is barking" << std::endl;
    }
};

int main() {
    Dog myDog;
    myDog.eat();   // 继承自Animal
    myDog.bark();  // Dog自己的方法
    return 0;
}

这个很简单，就是派生类可以继承基类的public方法，也可以通过public间接访问基类的private。

下面是三种继承方式

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;
};

class PublicDerived : public Base {
    void test() {
        publicVar = 1;      // OK: public → public
        protectedVar = 2;  // OK: protected → protected
        // privateVar = 3;  // Error: 永远不可访问
    }
};

class ProtectedDerived : protected Base {
    void test() {
        publicVar = 1;      // OK: public → protected
        protectedVar = 2;  // OK: protected → protected
        // privateVar = 3;  // Error
    }
};

class PrivateDerived : private Base {
    void test() {
        publicVar = 1;      // OK: public → private
        protectedVar = 2;  // OK: protected → private
        // privateVar = 3;  // Error
    }
};

int main() {
    PublicDerived pub;
    pub.publicVar = 1;     // OK
    
    ProtectedDerived prot;
    // prot.publicVar = 1; // Error: 已被降级为protected
    
    PrivateDerived priv;
    // priv.publicVar = 1; // Error: 已被降级为private
}

无论以哪种方式继承，都只能访问基类的protected和public，不能访问private,不同的继承方式只改变继承到的方法在派生类里的类型，从而影响在类的外部访问

接下来，在此基础上，对继承进行嵌套

class Base {
public:
    int publicVar=0;
    void print_base() {
        std::cout <<"Base " << publicVar <<" and " << protectedVar<<" address "<<&publicVar<<&protectedVar << std::endl;
    }
protected:
    int protectedVar=0;
private:
    int privateVar;
};

class PublicDerived : public Base {
public:
    void test() {
        publicVar = 1;      // OK: public → public
        protectedVar = 2;  // OK: protected → protected
        // privateVar = 3;  // Error: 永远不可访问
        std::cout << "Public " << publicVar << " and " << protectedVar << " address " << &publicVar << &protectedVar << std::endl;
    }
};
class Nesting : public PublicDerived {
public:
    void change(int a, int b)
    {
        publicVar = a;
        protectedVar = b;
        std::cout << "Nesting " << publicVar << " and " << protectedVar << " address " << &publicVar << &protectedVar << std::endl;
    }
};

我们看到test和change都是会改变两个变量的值的，那其中一个改变，是否每个类的这个变量都会改变呢？来验证一下

Nesting n1;
n1.print_base();
cout << n1.publicVar << endl;
n1.test();
n1.change(5, 7);
n1.print_base();
cout << n1.publicVar << endl;
n1.test();

输出

Base 0 and 0 address 000000173E2FF8C0000000173E2FF8C4
0
Public 1 and 2 address 000000173E2FF8C0000000173E2FF8C4
Nesting 5 and 7 address 000000173E2FF8C0000000173E2FF8C4
Base 5 and 7 address 000000173E2FF8C0000000173E2FF8C4
5
Public 1 and 2 address 000000173E2FF8C0000000173E2FF8C4

确实是牵一发而动全身的，因为三个类的public和protected都是同一内存

嵌套继承都是public型是这样的，那中间要是有一个protected呢？

class Base {
public:
    int publicVar=0;
    void print_base() {
        std::cout <<"Base " << publicVar <<" and " << protectedVar<<" address "<<&publicVar<<&protectedVar << std::endl;
    }
protected:
    int protectedVar=0;
private:
    int privateVar;
};

class ProtectedDerived : protected Base {
public:
    void test() {
        publicVar = 3;      // OK: public → protected
        protectedVar = 4;  // OK: protected → protected
        // privateVar = 3;  // Error
        std::cout << "Protected " << publicVar << " and " << protectedVar << " address " << &publicVar << &protectedVar << std::endl;
    }
};
class Nesting2 : public ProtectedDerived {
public:
    void change(int a, int b)
    {
        publicVar = a;
        protectedVar = b;
        std::cout << "Nesting " << publicVar << " and " << protectedVar << " address " << &publicVar << &protectedVar << std::endl;
    }
};

来访问一下

Nesting2 n;
//n.print_base();
n.test();
n.change(5, 2);
//cout << n.publicVar << endl;
//n.print_base();
n.test();

中间几行报错的已经注释了，n.print_base()，就要看到Base类，print_base()在base里是public，引用到ProtectedDerived就变成了protected型，再到Nesting2还是protected，所以无法在main里调用。test是从public到public，change是最后一个public，所以都能用。因为两个Var最后都要追溯到Base，所以每个类的Var地址都是一样的。