c++ 学习 · 继承 · 的使用

luck++

已于 2023-02-21 23:28:15 修改

阅读量155

点赞数 1

文章标签：开发语言学习 c++

于 2023-02-21 16:06:24 首次发布

本文链接：https://blog.csdn.net/qq_61344207/article/details/129101603

版权

概念：

有时候当我们需要好几种类的时候，有些类里面的成员可能会存在重复的情况，那就在想有没有一种办法可以，让这些类既有大家都共同拥有的，也要有自己独有的呢？ -- 继承

继承后父类的数据A会变成子类的一部分

class S
{
public:
    int a;
};

class W :public S //public为继承的方式
{
public:
    int b;
};

访问方式：

不可见意思就是子类的类外和类里都不能访问；protected / private：子类的类里可以访问，类外不可以。

如果基类成员需要在派生类中被访问，但是又不想被类外访问就定义为protect，这也看出保护成员限定符是因继承才出现的。

class 的默认继承方式是private ；struct 是 public

赋值转换

派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。把派生类中父类的那部分数据切来赋值过去 (只有公有继承的父子类，才可以实现)

但是父类的对象不能赋值给子类 ！

重定义：

如果子类和父类有同名的成员，那么访问子类里的这些数据，会优先访问子类的，屏蔽父类的，这个叫做隐藏，也叫做重定义。(但不建议定义的时候有重名的成员)

class S
{
public:
    void f()
    {
        cout << "Hello !" << endl;
    }
};

class M :public S
{
public:
    void f(int)
    {
        cout << "Hello !" << endl;
    }
};

int main()
{
    S a;
    M b;
    a.f();
    b.f();
    b.f(8);
    
    return 0;
}

可以看到这里的f函数也是隐藏(重定义) 。

不是重载哦重载需要两个这里的两个函数在同一作用域里面。

这个代码是无法正常允许的，会在编译的时候出错。

友元：

友元没有传递的这个说法，一个函数/类是父类的友元，但不是它不会是派生类的友元

友元关系不会被继承！！！！

派生类的friend函数可以访问派生类本身的一切变量，包括从父类继承下来的protected域中的变量。但是对父类来说，他并不是friend的。

class B;
class A
{
	friend B;
private:
	int a;
};


class B : public A
{
public:
	void fun()
	{
		cout << a;
	}
	int b;
};

这段代码中数据a 是被private限定的，无论什么继承都是private，不能访问的，但是如果我让子类B成为了父类A的友元，就可以在B类里面访问了，当然类外依旧是不可以的！！！

静态成员：

在继承中，静态成员，父类和子类都可以访问，属于是共用的

class A
{
public:
	static void dunc()
	{
		cout << "Hello" << endl;
	}
	int a;
};

class B : public A
{
public:
	
	int b;
};

int main()
{
	B::dunc();

	return 0;
}

默认函数：

子类会优先调用父类的构造函数初始化那些继承自父类的成员，然后再初始化自己的。

class S
{
public:
	S(int num )
	{
		x = num;
	}

	int x;
};

class M :public S
{
public:
	M(int m = 11, int n = 22)
		: y(n),
		x(m)
	{ }

	int y;
};


int main()
{
	M b;
	return 0;
}

这个代码是会报错的哦。S类没有构造函数，而子类会优先调用父类的构造，就报错了，还有一个错误：

这个可以这样解决(赋值拷贝构造函数也是这样)：

class S
{
public:
	S(int num)
	{
		x = num;
	}

	int x;
};

class M :public S
{
public:
	M(int m = 11, int n = 22)
		: y(n),	
		S(m)
	{ }

	int y;
};


int main()
{
	M b;
	
	return 0;
}

当然这样 x 就变成11了，这里依然也是先调用S的构造函数，初始化列表初始化顺序是看变量的声明顺序的，默认继承自父类的成员是最前的

class S
{
public:
	S(int num)
	{
		x = num;
	}

	S(const S& data)
	{
		x = data.x;
	}

	S& operator=(const S& data)
	{
		if (this != &data)
		{
			x = data.x;
		}
	}
	int x;
};

class M :public S
{
public:
	M(int m = 11, int n = 22)
		: y(n),	
		S(m)
	{ }

	M(const M& data)
		:S(data.x),
		y(data.y)
	{ }

	M& operator=(const M& data)
	{
		if (this != &data)
		{
			S::operator=(data.x);
			y = data.y;
		}
	}
	int y;
};

拷贝构造函数需要声明是父类的，不然会和子类的拷贝构造函数构成隐藏

子类的析构函数不需要显示的调用父类的析构函数：

① 显示调用如果不声明会构成隐藏：因为多态的需要，析构函数名会被统一为destructor()

② 即使你声明了是调用父类的析构，因为析构顺序就是先子后父，子类析构完会自动调用父类的