cpp primer plus笔记010-继承

最新推荐文章于 2024-08-23 17:37:15 发布
最新推荐文章于 2024-08-23 17:37:15 发布
阅读量85 收藏
点赞数
分类专栏： c++ 文章标签： 笔记 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LEVIATHANq/article/details/133649049
版权
  1. 特征公有继承保护继承私有继承
    公有成员变成派生类公有成员派生类保护成员派生类私有成员
    保护成员变成派生类保护成员派生类保护成员派生类私有成员
    私有成员变成只能通过基类接口访问只能通过基类接口访问只能通过基类接口访问
    能否隐式向上转换是是(只能在派生类中)是
    如果使用私有或者保护派生导致基类公有成员无法作为派生类的数据在类的外部访问，可以通过using的方法重定义数据访问权限 
    class Base
{
private:
	int a = 0;
protected:
	int b = 0;
public:
	int c = 0;
};
class Son1 :public Base
{
	void Fun1()
	{
		//this->a = 0;X 
		this->b = 0;
		this->c = 0;
	}
};

  2. 派生类构造函数可以通过初始化列表来调用基类的构造函数(可以是默认复制构造函数),如果没有调用基类的构造函数，则派生类的构造函数会隐式的调用基类的无参构造函数:

    #include<cstring>
#include<iostream>
class Base
{
private:
	int a = 0;
protected:
	int b = 0;
public:
	int c = 0;
	Base(int baseA, int baseB, int baseC) :a(baseA), b(baseB), c(baseC) {};
};
class Son :public Base
{
	int d;
	void Fun1()
	{
		//this->a = 0;
		this->b = 0;
		this->c = 0;
	}
	Son(int baseA, int baseB, int baseC, int baseD) :Base(baseA, baseB, baseC), d(baseD) {};
	Son(Base base, int baseD) :Base(base), d(baseD) {};
};
int main()
{
	
	return 0;
}

  3. virtual使用:

    • 修饰类中的成员函数，如果基类中的的成员函数使用类virtual，则派生类可以重写基类的该成员函数
    • 如果定义了基类的指针或者引用，并且该指针和引用使用派生类构造或者赋值，如果调用一个基类和派生类都有的函数，如果基类同名函数没有被virtual修饰，则会调用基类的函数，否则调用派生类的函数。
    • 当有数据在基类构造函数使用new运算符创建出来时，基类最好使用虚析构函数，以免上述的引用和指针在程序结束时调用基类的析构函数。
    • 析构函数不能被继承。
    • 针对部分对象子类在某相同的功能上实现效果的巨大差异，基类可以定义一个不实现其作用的虚函数，即纯虚函数，此函数在虚函数基础上在函数声明末尾加上 = 0,一旦类定义了纯虚函数，则这个类被称为抽象类;
    #include<cstring>
#include<iostream>
class Food
{
private:
	static const bool CanEat = true;
protected:
	enum class Color { kRed, kYellow, kGreen, kBlue, kPink };
	enum class Teste { kSour, kSweet, kBitter, kHot, ksalty };
	virtual bool ShowCanEat()
	{
		return CanEat;
	}
public:
	virtual Color ShowColor() = 0;
	virtual Teste ShowTest() = 0;
	friend std::ostream& operator<<(std::ostream& os, const Color& color)
	{
		os << (int)color;
		return os;
	}
	friend std::ostream& operator<<(std::ostream& os, const Teste& teste)
	{
		os << (int)teste;
		return os;
	}
};
class Fruit : public Food
{
public:
	Color ShowColor()
	{
		return Color::kYellow;
	}
	virtual bool ShowCanEat()
	{
		return Food::ShowCanEat();
	}
	virtual Teste ShowTest()
	{
		return Teste::kSweet;
	}
};
class Apple : public Fruit
{
	Color ShowColor()
	{
		return Color::kGreen;
	}
	virtual Teste ShowTest()
	{
		return Teste::kHot;
	}
};
int main()
{
	Apple pear = Apple();
	Fruit* ptrApple = &pear;
	std::cout << ptrApple->ShowColor() << std::endl;
	std::cout << ptrApple->ShowTest() << std::endl;
	return 0;
}

    2
3

    #define _CRT_SECURE_NO_WARNINGS 1
#include<cstring>
#include<iostream>
class baseDMA
{
private:
	char* label;
	int rating;
public:
	baseDMA(const char* l = "null", int r = 0)
	{
		label = new char[std::strlen(l) + 1];
		std::strcpy(label, l);
		rating = r;
	}
	baseDMA(const baseDMA& rs) :baseDMA(rs.label, rs.rating) { ; }
	baseDMA& operator=(const baseDMA& rs)
	{
		if (this == &rs) return*this;
		delete[] label;
		label = new char[std::strlen(rs.label) + 1];
		std::strcpy(label, rs.label);
		rating = rs.rating;
		return *this;
	}
	virtual ~baseDMA()
	{
		delete[] label;
	}
};
class hasDMA : public baseDMA
{
private:
	char* style;
public:
	hasDMA(const hasDMA& hs) :baseDMA(hs)
	{
		style = new char[std::strlen(hs.style) + 1];
		std::strcpy(style, hs.style);
	}
	hasDMA& operator=(const hasDMA& hs)
	{
		if (this == &hs) return *this;
		baseDMA::operator=(hs);//如果使用*this=hs会导致编译器递归调用hasDMA的赋值运算符
		delete[] style;
		style = new char[std::strlen(hs.style) + 1];
		std::strcpy(style, hs.style);
		return *this;
	}
};
int main()
{
	return 0;
}

  4. 虚继承P453

  5. 类模板,注意template中的typename和class并没有实际意义上的区别，而且template还可以添加参数,而且参数可以提供默认值。CPP允许部分具体化，如设置部分类型参数类指针类型，整形等

    	#include<iostream>
	//template<class TYPE1,typename TYPE2,int n>
	template<class ClassType = int>
	class Stack
	{
	private:
		enum { SIZE = 10 };
		int stackSize;
		ClassType* items;
		int top;
	public:
		explicit Stack(int ss = SIZE);
		Stack(const Stack& st);
		~Stack() { delete[] items; }
		bool IsEmpty() { return top == 0; };
		bool IsFull() { return top == stackSize; };
		bool Push(const ClassType& item);
		bool Pop(ClassType& item);
		Stack& operator=(const Stack& st);
	};
	
	template<> 
	class Stack<double>
	{
	private:
		int a = 0;
	};
	
	template<class ClassType>
	Stack<ClassType>::Stack(int ss) :stackSize(ss), top(0)
	{
		items = new ClassType[stackSize];
	}
	
	template<class ClassType>
	bool Stack<ClassType>::Push(const ClassType& item)
	{
		if (top < stackSize)
		{
			items[top++] = item;
			return true;
		}
		else return false;
	}
	
	template<class ClassType>
	bool Stack<ClassType>::Pop(ClassType& item)
	{
		if (top > 0)
		{
			item = items[--top];
			return true;
		}
		else return false;
	}
	
	template<class ClassType>
	Stack<ClassType>& Stack<ClassType>::operator=(const Stack<ClassType>& st)
	{
		if (this == &st) return *this;
		delete[] items;
		stackSize = st.stackSize;
		top = st.top;
		items = new ClassType[stackSize];
		for (int i = 0; i < top; ++i)
		{
			items[i] = st.items[i];
		}
		return *this;
	}
	
	template<class ClassType>
	Stack<ClassType>::Stack(const Stack& st)
	{
		stackSize = st.stackSize;
		top = st.top;
		items = new ClassType[stackSize];
		for (int i = 0; i < top; ++i)
		{
			items[i] = st.items[i];
		}
	}
	
	template<class T1,class T2> 
	class Pair{};
	
	template<class T1>
	class Pair<T1, int>{};
	
	template<class T1,class T2>
	class Pair<T1*, T2*> {};
	int main()
	{
		Stack<int> st1;
		Stack<> st2;
		return 0;
	}

  6. CPP可以使用成员模板，即在类中的数据成员或者函数成员上方创建模板

    #include<iostream>
template<class T>
class beta
{
private:
	template<typename V>
	class hold
	{
	private:
		V val;
	public:
		hold(V v = 0) :val(v) {};
		void show() const { std::cout << val << std::endl; }
		V Value() const { return val; }
	};
	hold<T> q;
	hold<int> n;
public:
	beta(T t, int i) :q(t), n(i) {};
	template<typename U> 
	U blab(U u, T t) { return (n.Value() + q.Value()) * u / t; }
	void Show() const { q.show(); n.show(); }
};
int main()
{
	beta<double> guy{ 3.5,3 };
	guy.Show();
	std::cout << guy.blab(10, 2.3) << std::endl;
	std::cout << guy.blab(10.0, 2.3) << std::endl;
}

    若需要在外部定义的话，上面代码相当于下面的代码:

    #include<iostream>
template<class T>
class beta
{
private:
	template<typename V>
	class hold;
	hold<T> q;
	hold<int> n;
public:
	beta(T t, int i) :q(t), n(i) {};
	template<typename U> 
	U blab(U u, T t);
	void Show() const { q.show(); n.show(); }
};

template<class T>
	template<typename V>
	class beta<T>::hold
	{
	private:
		V val;
	public:
		hold(V v=0):val(v){}
		void show()const { std::cout << val << std::endl; }
		V Value() const { return val; }
	};

template<class T>
	template<typename U>
	U beta<T>::blab(U u, T t)
	{
		return (n.Value() + q.Value()) * u / t;
	}
int main()
{
	beta<double> guy{ 3.5,3 };
	guy.Show();
	std::cout << guy.blab(10, 2.3) << std::endl;
	std::cout << guy.blab(10.0, 2.3) << std::endl;
}

    3.5
3
28
28.2609

  7. 如果类中需要一个类似于需要未知的模板类作为使用，可以作以下定义:

    #include<iostream>
template<class ClassType>
class Stack
{
private:
	enum { SIZE = 10 };
	int stackSize;
	ClassType* items;
	int top;
public:
	explicit Stack(int ss = SIZE);
	Stack(const Stack& st);
	~Stack() { delete[] items; }
	bool IsEmpty() { return top == 0; };
	bool IsFull() { return top == stackSize; };
	bool Push(const ClassType& item);
	bool Pop(ClassType& item);
	Stack& operator=(const Stack& st);
};

template<class ClassType>
Stack<ClassType>::Stack(int ss) :stackSize(ss), top(0)
{
	items = new ClassType[stackSize];
}

template<class ClassType>
bool Stack<ClassType>::Push(const ClassType& item)
{
	if (top < stackSize)
	{
		items[top++] = item;
		return true;
	}
	else return false;
}

template<class ClassType>
bool Stack<ClassType>::Pop(ClassType& item)
{
	if (top > 0)
	{
		item = items[--top];
		return true;
	}
	else return false;
}

template<class ClassType>
Stack<ClassType>& Stack<ClassType>::operator=(const Stack<ClassType>& st)
{
	if (this == &st) return *this;
	delete[] items;
	stackSize = st.stackSize;
	top = st.top;
	items = new ClassType[stackSize];
	for (int i = 0; i < top; ++i)
	{
		items[i] = st.items[i];
	}
	return *this;
}

template<class ClassType>
Stack<ClassType>::Stack(const Stack& st)
{
	stackSize = st.stackSize;
	top = st.top;
	items = new ClassType[stackSize];
	for (int i = 0; i < top; ++i)
	{
		items[i] = st.items[i];
	}
}

namespace stack
{
	template<class T>
	class beta
	{
	private:
		template<typename V>
		class hold;
		hold<T> q;
		hold<int> n;
	public:
		beta(T t, int i) :q(t), n(i) {};
		template<typename U>
		U blab(U u, T t);
		void Show() const { q.show(); n.show(); }
	};

	template<class T>
	template<typename V>
	class beta<T>::hold
	{
	private:
		V val;
	public:
		hold(V v = 0) :val(v) {}
		void show()const { std::cout << val << std::endl; }
		V Value() const { return val; }
	};

	template<class T>
	template<typename U>
	U beta<T>::blab(U u, T t)
	{
		return (n.Value() + q.Value()) * u / t;
	}
}

template<template<typename T> class Thing>//未知类型模板定义
class Crab
{
private:
	Thing<int> s1;//未知类型的模板类
	Thing<double> s2;//未知类型的模板类
public:
	Crab() {};
	bool Push(int a, double x) { return s1.Push(a) && s2.Push(x); }
	bool Pop(int& a, double& x) { return s1.Pop(a) && s2.Pop(x); }
};
int main()
{
	Crab<Stack> nebula;
	int ni;
	double nb;
	while (std::cin >> ni >> nb && ni > 0 && nb > 0)
	{
		if (!nebula.Push(ni, nb)) break;
	}
	while (nebula.Pop(ni, nb))
	{
		std::cout << ni << " " << nb << std::endl;
	}
}

  8. 模板类声明可以有友元，模板类的友元分以下三类:

    • 非模板友元。
    • 约束模板友元，即友元类型取决于类被实体化时的类型。
    • 非约束模板友元，即友元的所有具体化都是类的每个具体化的友元。
    • 注：模板为不同类型的对象使用的类是不同的，如int的对象使用的int具体化的类，double的对象使用的是double具体化的类。在约束模板友元函数中在类前面声明一个模板函数的原因,友元函数是一个模板函数的实例化，且实例化的类型与类模板类型相关.
    #include<iostream>
template<class T>
class HasFriend
{
private:
   T item;
   static int ct;
public:
   HasFriend(const T& i) :item(i) { ++ct; }
   ~HasFriend() { --ct; }
   friend void counts();
   friend void reports(HasFriend<T>&);
};
template<class T>
int HasFriend<T>::ct = 0;
//non-template friend to all HasFriend<T> classes
void counts()
{
   std::cout << "int counts: " << HasFriend<int>::ct << "; ";
   std::cout << "double count: " << HasFriend<double>::ct << std::endl;
}
//non-template friend to the HasFriend<int> class 
void reports(HasFriend<int>& hf)
{
   std::cout << "HasFriend<int>: " << hf.item << std::endl;
}
//non-template friend to the HasFriend<double> class
void reports(HasFriend<double>& hf)
{
   std::cout << "HasFriend<double>: " << hf.item << std::endl;
}
int main()
{
   std::cout << "No objects declared; ";
   counts();
   HasFriend<int> hfil1(10);
   std::cout << "After hfil1 declared; ";
   counts();
   HasFriend<int> hfil2(20);
   std::cout << "After hfil2 declared; ";
   counts();
   HasFriend<double> hfdb(10.5);
   std::cout << "After hfdb declared; ";
   counts();
   reports(hfil1);
   reports(hfil2);
   reports(hfdb);
   return 0;
}

    No objects declared; int counts: 0; double count: 0
After hfil1 declared; int counts: 1; double count: 0
After hfil2 declared; int counts: 2; double count: 0
After hfdb declared; int counts: 2; double count: 1
HasFriend<int>: 10
HasFriend<int>: 20
HasFriend<double>: 10.5

    #include<iostream>
template<typename T>
class ManyFriend
{
private:
	T item;
public:
	ManyFriend(const T& i) :item(i) {};
	template<typename C, typename D> friend void show2(C&, D&);
};
template <typename C, typename D> void show2(C& c, D& d)
{
	std::cout << c.item << ", " << d.item << std::endl;
}
int main()
{
	ManyFriend<int> hfi1(10);
	ManyFriend<int> hfi2 = 20;
	ManyFriend<double> hfdb{ 10.5 };
	std::cout << "hfi1, hfi2: ";
	show2(hfi1, hfi2);
	std::cout << "hfdb, hfi2: ";
	show2(hfdb, hfi2);
	return 0;
}

    hfi1, hfi2: 10, 20
hfdb, hfi2: 10.5, 20 

    #include<iostream>
template<typename T> void counts();
template<typename T> void report(T&);

template<class TT>
class HasFriendT
{
private:
	TT item;
	static int ct;
public:
	HasFriendT(const TT& i) :item(i) { ++ct; };
	~HasFriendT() { --ct; };
	friend void counts<TT>();
	friend void report<>(HasFriendT<TT> &);
};

template<typename T>
int HasFriendT<T>::ct = 0;

template<typename T>
void counts()
{
	std::cout << "template size: " << sizeof(HasFriendT<T>) << "; ";
	std::cout << "template counts(): " << HasFriendT<T>::ct << std::endl;
}

template<typename T>
void report(T& hf)
{
	std::cout << hf.item << std::endl;
}

 
int main()
{
	counts<int>();
	HasFriendT<int> hfi1(10);
	HasFriendT<int> hfi2(20);
	HasFriendT<double> hfdb(10.5);
	report(hfi1);
	report(hfi2);
	report(hfdb);
	std::cout << "counts<int>() output:\n";
	counts<int>();
	std::cout << "count<int>() output:\n";
	counts<double>();
	return 0;
}

    hfi1, hfi2: 10, 20
hfdb, hfi2: 10.5, 20

  9. CPP可以为模板起别名,但是用的数using，当然using语法可以用于非模板，这是与typedef等价:

    template<typename T> using arrtype=std::array<T,12>;
//重命名后可以进行一下创建
arrtype<double> gallons;
arrtype<int> days;
arrtype<std::string> months;

typedef const char *pc1;
//上面语法相当于下面的语法
using pc1=const char*;

typedef const int *(*pa1)[10];
//上面语法相当于下面的语法
using pa1=const int *(* )[10];
北极星璇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cpp primer plus笔记06-函数
LEVIATHANq的博客
10-07 86
对于重载函数的选择，编译器倾向于优先选择非模板函数，如果没有非模板函数，则倾向于选择从类型等各方面来说相对具体的函数，如果没有一个函数比其他函数更具体，或者没有与之相匹配的函数，则会产生错误，但是向下面的情况(第二行)，编译器会倾向于选择模板函数，而不是非模板函数。函数返回值可以是引用变量，这样就不会把数据复制到一个新的临时的位置，效率会更高，但是引用变量尽量返回函数参数的的变量，引用尽量是自定义数据结构这种复杂的数据结构，而且返回值如果是引用类型尽量加const修饰。声明为一个常量引用。
cpp primer plus笔记02-处理数据
LEVIATHANq的博客
10-06 149
类型检查的目的是为了防止类型错误的发生，例如将一个整数赋值给一个字符串变量，或者将一个函数的返回值赋值给一个不兼容的变量等。通过对代码进行类型检查，可以在编译或运行时发现这些类型错误，并提前进行修正，从而避免在程序执行过程中出现潜在的类型相关问题。以两个下划线开头或者以下划线和大写字母打头的名称被保留给实现使用(编译器及其使用的资源)，以一个下划线开头的名称被保留给实现，用作全局标识符，例如__fools,_Mystars3。：用于进行静态类型转换，它在编译时进行类型检查，不进行运行时的安全性检查。
cpp primer plus笔记03-复合类型
LEVIATHANq的博客
10-06 110
由于缺少char8_t，char16_t和char32_t的标准输出流，以上三种类型的字符串需要转化为窄字符串或者宽字符串，才能有意义的写入标准输出流，而且一般只有写入文件时才真正有用。CPP11支持列表初始化运用于结构体，且等号可以省略，如果列表初始化的大括号未包含任何东西，则各个成员被设置为零，CPP11列表初始化不允许缩窄转换。结构体允许在函数内部和外部定义，但是定义在函数内部的结构体只能在该声明所属的函数使用,但CPP提倡外部结构声明。不使用delete来释放不是new分配的内存。
C++_primer_plus学习笔记 第13章 类继承
Flying_Dutchman_的博客
07-12 387
is-a关系继承 公有派生 保护访问 构造函数成员初始化列表 向上和向下强制转换 虚成员函数 早起（静态）联编和晚期（动态）联编 抽象基类 纯虚函数 何时及如何使用公有继承
cpp_primer_plus：C ++ Primer Plus硬件
02-23
cpp_primer_plus C ++ Primer Plus注释和作业 第二章功课完成 第四章注意事项 第四章硬件完成 第五章笔记 第五章硬件完成 第6章注释（跳过文件I / O） 2021年2月12日的第7.3.5章 第7.7章使用strctptr.cpp 第7.8章
CppPrimer：C ++ Primer第五次练习的解决方案
02-21
C ++ Primer解决方案第五答案 笔记 使用GCC 4.9+ ， Clang 3.4+ MSVC 14+ ， MSVC 14+。 使用-std=c++11 （推荐： -pedantic -Wall ）标志进行编译。 您发现不正确的信息了吗？ 。 内容 第一部分：基础知识 第二...
【C++ Primer Plus】笔记第1章 预备知识
10-28
在编程领域，C++ Primer Plus 是一本广泛认可的入门教材，它为初学者提供了深入理解C++语言的基础。C++是C语言的一个增强版，增加了面向对象编程的概念，使得程序员能够更好地组织和管理代码，提高代码的重用性和可...
primer_plus_cpp_part1
04-01
《C++ Primer Plus 第六版》是学习C++编程的一本经典教材，它全面而深入地介绍了C++语言的基础知识和高级特性。本资源提供的是该书部分内容的扫描版，分为多个部分，此处讨论的是"cpp_part1"。在学习这部分内容时，...
Cpp-primer-notes:阅读cpp入门5版时要注意的事项
03-08
《C++ Primer Plus》是C++编程领域里一本广受欢迎的入门教材，其第五版更是对C++11和C++14标准进行了全面更新。这份"Cpp-primer-notes"很可能是作者在学习过程中整理的一些重点、难点以及易错点的集合，对于初学者和...
MySQL 相关知识笔记
最新发布
weixin_68929783的博客
08-23 807
以上是根据 B 站黑马课程学习后的 MySQL 笔记，为了日后复习和给别人参考而整理，希望对大家有所帮助。同时，在实际应用中，还需要根据具体情况合理使用索引、约束等功能，以提高数据库的性能和数据的完整性。
Freertos学习笔记
qq_45031559的博客
08-21 623
Freertos学习笔记
Conditional Flow Matching: Simulation-Free Dynamic Optimal Transport论文阅读笔记
weixin_46103454的博客
08-20 376
假设给定一个目标流pt和生成它的向量场ut .学习与pt相匹配的流的一种方法是通过对目标向量场的回归进行梯度下降。
分享思源笔记的几个骚操作
2301_80064376的博客
08-21 316
本文章主要分享下思源笔记软件最喜爱的几个功能
[Matsim]Matsim学习笔记-车辆和订单匹配的逻辑
机器学习菜鸟
08-23 191
这个方法体现了在DRT系统中对未计划请求进行调度的逻辑，包括对旧请求的重试和新请求的调度。通过并行处理车辆入口信息的创建，提高了调度过程的效率。matsim扩展包中DRT动态线路的场景是，给定一些车辆、一些订单，进行车辆和订单的匹配，类似滴滴的拼车功能。的方法，它用于调度未计划的DRT（需求响应交通）请求。操作，确保了在调度过程中对已处理的请求进行清理，避免重复调度。
全栈笔记_浏览器工作原理篇（浏览器架构）
wwv的博客
08-20 104
浏览器是用于访问互联网资源的软件，其工作原理涉及多个组件的协同工作，包括用户界面、浏览器引擎、渲染引擎、JavaScript解释器和网络模块。
React学习笔记，从入门到砸门
留白声的博客
08-20 1038
react详细自我学习笔记，内容包括JSX、Redux、Router等
笔记redis
风止的博客
08-22 770
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
谷粒商城实战笔记-236~238-商城业务-购物车-环境搭建
epitomizelu的专栏
08-22 882
这一节的内容主要分析购物的业务逻辑和设计存储购物车的选型及数据结构。①把整个购物车封装为一个对象CartVo。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值