cpp primer plus笔记011-友元，异常和其他

最新推荐文章于 2024-11-14 08:20:05 发布
最新推荐文章于 2024-11-14 08:20:05 发布
阅读量156 收藏
点赞数
分类专栏： c++ 文章标签： 笔记 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LEVIATHANq/article/details/133649125
版权

  1. 如果一个类A里面声明的一个友元类B，那么这个被声明的友元类B的全部函数对于A都是友元函数，即可以访问A中所有成员的函数

    #include<iostream>
class MajorisA
{
private:
	double Light = 0;
	double Radius = 0;
public:
	friend class MajorisB;
	MajorisA(double l, double r) :Light(l), Radius(r) {};
	void ShowLight()
	{
		std::cout << "A: " << Light << std::endl;
	}
	void ShowRadius()
	{
		std::cout << "A: " << Radius << std::endl;
	}
};
class MajorisB
{
private:
	double Light = 0;
	double Radius = 0;
public:
	MajorisB(double l, double r) :Light(l), Radius(r) {};
	void ShowLight(const MajorisA& a)
	{
		std::cout << "B: " << a.Light << " " << Light << std::endl;
	}
	void ShowRadius(const MajorisA& a)
	{
		std::cout << "B: " << a.Radius << " " << Radius << std::endl;
	}
};

int main()
{
	MajorisA a(5.0, 10.0);
	MajorisB b(1.0, 2.0);
	a.ShowLight();
	a.ShowRadius();
	b.ShowLight(a);
	b.ShowRadius(a);
	return 0;
}

  2. 如果只希望B类中部分成员函数成为A的友元函数，可以如下实现:(注:需要声明A类，这样才能在B类中声明有关A类的函数，如果先定义A类，再定义B类，这会导致A类编译到友元函数GetLight时无法在B类中查找到相关函数声明，导致编译错误)

    #include<iostream>

class MajorisA;
class MajorisB
{
private:
	double Light = 0;
	double Radius = 0;
public:
	MajorisB(double l, double r) :Light(l), Radius(r) {};
	void ShowLight()
	{
		std::cout << "B: " << Light << std::endl;
	}
	void ShowRadius()
	{
		std::cout << "B: " << Radius << std::endl;
	}
	void GetLight(const MajorisA& a);
};
class MajorisA
{
private:
	double Light = 0;
	double Radius = 0;
	int data = 0;
public:
	friend void MajorisB::GetLight(const MajorisA& a);
	MajorisA(double l, double r) :Light(l), Radius(r) {};
	void ShowLight()
	{
		std::cout << "A: " << Light << std::endl;
	}
	void ShowRadius()
	{
		std::cout << "A: " << Radius << std::endl;
	}
};

void MajorisB::GetLight(const MajorisA& a)
{
	std::cout << "Fri: " << a.Light << " " << a.Radius << std::endl;
}

int main()
{
	MajorisA a(10.0, 50.0);
	MajorisB b(5.0, 20.0);
	a.ShowLight();
	a.ShowRadius();
	b.ShowLight();
	b.ShowRadius();
	b.GetLight(a);
	return 0;
}

  3. CPP还可以声明共同友元，即在A类和B类中声明两个或者多个一样的友元函数:

    #include<iostream>
class MajorisA;
class MajorisB
{
private:
	double Light = 0;
	double Radius = 0;
public:
	MajorisB(double l, double r) :Light(l), Radius(r) {};
	void ShowLight()
	{
		std::cout << "B: " << Light << std::endl;
	}
	void ShowRadius()
	{
		std::cout << "B: " << Radius << std::endl;
	}
	friend void SetLight(const MajorisA& a, MajorisB& b);
	friend void SetLight(const MajorisB& b, MajorisA& a);
};
class MajorisA
{
private:
	double Light = 0;
	double Radius = 0;
	int data = 0;
public:
	friend void SetLight(const MajorisA& a, MajorisB& b);
	friend void SetLight(const MajorisB& b, MajorisA& a);
	MajorisA(double l, double r) :Light(l), Radius(r) {};
	void ShowLight()
	{
		std::cout << "A: " << Light << std::endl;
	}
	void ShowRadius()
	{
		std::cout << "A: " << Radius << std::endl;
	}
};

void SetLight(const MajorisA& a, MajorisB& b)
{
	b.Light = a.Light;
}
void SetLight(const MajorisB& b, MajorisA& a)
{
	a.Light = b.Light;
}

int main()
{
	MajorisA a(10.0, 50.0);
	MajorisB b(5.0, 20.0);
	a.ShowLight();
	a.ShowRadius();
	b.ShowLight();
	b.ShowRadius();
	std::cout << std::endl;
	SetLight(a, b);
	a.ShowLight();
	a.ShowRadius();
	b.ShowLight();
	b.ShowRadius();
	MajorisA c(100.0, 100.0);
	SetLight(b, c);
	std::cout << std::endl;
	c.ShowLight();
	c.ShowRadius();
	b.ShowLight();
	b.ShowRadius();
	return 0;
}

  4. CPP可以使用嵌套类，即在一个类中定义一个类，其中后者被private，public，protected修饰的效果类似于被前者定义的数据成员被这三中修饰符其中一个修饰的效果:

    #include<iostream>
class Queue
{
public:
	class Node
	{
	public:
		int item;
		Node* next;
		Node(const int& i);
	};
	bool enqueue(const int& item);
};

Queue::Node::Node(const int& i) :item(i), next(0) {};
bool Queue::enqueue(const int& item)
{
	//if(isfull()) return false;
	Node* add = new Node(item);
	//......
	return true;
}
int main()
{
	
	return 0;
}

    当然嵌套类也可以嵌套到模板中:

    template<class ITEM>
class Queue
{
public:
	class Node
	{
	public:
		ITEM item;
		Node* next;
		Node(const ITEM i);
	};
	bool enqueue(const ITEM& item);
};

template<class ITEM>
Queue<ITEM>::Node::Node(const ITEM i) :item(i), next(0) {};

template<class ITEM>
bool Queue<ITEM>::enqueue(const ITEM& item)
{
	//if(isfull()) return false;
	Node* add = new Node(item);
	//......
	return true;
}

  5. CPP也有类似于CS的异常处理,注throw可以是任何类型的数据,包括class，而catch的()只会捕获()中类型的数据，一旦抛出异常，catch会捕获相关类型异常，如果抛出的异常没有被对应的catch检测到，则vs会终止程序运行。

    #include<iostream>
double hmean(double a, double b);
int main()
{
	double x, y, z;
	std::cout << "Enter next set of numbers <q to quit>; ";
	while (std::cin>>x>>y)
	{
		try
		{
			z = hmean(x, y);
		}
		catch (const char* exc)
		{
			std::cout << exc << std::endl;
			std::cout << "Enter a new pair of numbers";
			continue;
		}
		std::cout << "Harmonic mean of " << x << " and " << y
			<< "is " << z << std::endl;
		std::cout << "Enter next set of numbers <q to quit>; ";
	}
	std::cout << "Bye!\n";
	return 0;
}
double hmean(double a, double b)
{
	if (a == -b)
		throw "bad hmean() arguments: a = -b not allowed";
	return 2.0 * a * b / (a + b);
}

    Enter next set of numbers <q to quit>; 2 5
Harmonic mean of 2 and 5is 2.85714
Enter next set of numbers <q to quit>; 2 -2
bad hmean() arguments: a = -b not allowed
Enter a new pair of numbers3 3
Harmonic mean of 3 and 3is 3
Enter next set of numbers <q to quit>; 4.23 -4.23
bad hmean() arguments: a = -b not allowed
Enter a new pair of numbers4.123123 -4.123123
bad hmean() arguments: a = -b not allowed
Enter a new pair of numbers4.123123123123 -4.123123123123
bad hmean() arguments: a = -b not allowed
Enter a new pair of numbersq
Bye!

    Enter two numbers: 2 -2
hmean (2, -2); invalid arguments: a = -b
Try again.
3 4
Harmonic mean of 3 and 4 is 3.42857
Geometric mean of 4 and 4 is 3.4641
Enter next set of numbers <q to quit>:-1 1
hmean (-1, 1); invalid arguments: a = -b
Try again.
-1 2
Harmonic mean of -1 and 2 is -4
gmean() arguments should be >= 0
Value used:-1, 2
Sorry, you don't get to play any more.
Bye!

  6. CPP栈解退，假设程序中某个函数因抛出异常而终止，程序将释放该函数在栈中的内存，然后继续释放调用该函数的函数在栈中的内存，以此类推，直到执行到try块语句，然后控制权将转到块尾的异常控制程序，在这个多个函数不断释放的过程中，对于栈中局部变量的类对象，类的析构函数将被调用。注:抛出异常指的是throw，如果在catch语块中的throw后面不接语句，会抛出catch所捕获的异常，如果不在catch语块中的throw后面不接语句，会抛出std::exception的异常,(std::exception是CPP库中的一个类，用于表示通用的异常情况)

    #include<iostream>
#include<cmath>
#include<string>
class bad_hmean
{
private:
	double v1;
	double v2;
public:
	bad_hmean(double a = 0, double b = 0) :v1(a), v2(b) {};
	void mesg();
};
inline void bad_hmean::mesg()
{
	std::cout << "hmean (" << v1 << ", " << v2 << "); "
		<< "invalid arguments: a = -b\n";
}
class bad_gmean
{
public:
	double v1;
	double v2;
	bad_gmean(double a = 0, double b = 0) :v1(a), v2(b) {};
	const char* mesg();
};
inline const char* bad_gmean::mesg()
{
	return "gmean() arguments should be >= 0\n";
}

class demo
{
private:
	std::string word;
public:
	demo(const std::string& str)
	{
		word = str;
		std::cout << "demo " << word << " created\n";
	}
	~demo()
	{
		std::cout << "demo " << word << " destroted\n";
	}
	void show() const
	{
		std::cout << "demo " << word << " lives\n";
	}
};

double hmean(double a, double b);
double gmean(double a, double b);
double means(double a, double b);

int main()
{
	double x, y, z;
	std::cout << "Enter two numbers: ";
	demo d1("Found in block in main()");
	while (std::cin >> x >> y)
	{
		try
		{
			z = means(x, y);
			std::cout << "Harmonic mean of " << x << " and " << y
				<< " is " << z << std::endl;
			std::cout << "Geometric mean of " << y << " and " << y
				<< " is " << z << std::endl;
			std::cout << "Enter next set of numbers <q to quit>:";
		}
		catch (bad_hmean& hg)
		{
			hg.mesg();
			std::cout << "Try again.\n";
			continue;
		}
		catch (bad_gmean& bg)
		{
			std::cout << bg.mesg();
			std::cout << "Value used:" << bg.v1 << ", "
				<< bg.v2 << std::endl;
			std::cout << "Sorry, you don't get to play any more.\n";
			break;
		}
	}
	d1.show();
	std::cout << "Bye!\n";
	std::cin.get();
	std::cin.get();
	return 0;
}
double hmean(double a, double b)
{
	if (a == -b) throw bad_hmean(a, b);
	return 2.0 * a * b / (a + b);
}
double gmean(double a, double b)
{
	if (a * b < 0) throw bad_gmean(a, b);
	return std::sqrt(a * b);
}
double means(double a, double b)
{
	double am, hm, gm;
	demo d2("found in means()");
	am = (a + b) / 2.0;
	try
	{
		hm = hmean(a, b);
		gm = gmean(a, b);
	}
	catch (bad_hmean& bg)
	{
		bg.mesg();
		std::cout << "Caught in means\n";
		throw;
	}
	d2.show();
	return (am + hm + gm) / 3.0;
}

    Enter two numbers: demo Found in block in main() created
2 2
demo found in means() created
demo found in means() lives
demo found in means() destroted
Harmonic mean of 2 and 2 is 2
Geometric mean of 2 and 2 is 2
Enter next set of numbers <q to quit>:-4 4
demo found in means() created
hmean (-4, 4); invalid arguments: a = -b
Caught in means
demo found in means() destroted
hmean (-4, 4); invalid arguments: a = -b
Try again.
-4 -4
demo found in means() created
demo found in means() lives
demo found in means() destroted
Harmonic mean of -4 and -4 is -1.33333
Geometric mean of -4 and -4 is -1.33333
Enter next set of numbers <q to quit>:-4 1
demo found in means() created
demo found in means() destroted
gmean() arguments should be >= 0
Value used:-4, 1
Sorry, you don't get to play any more.
demo Found in block in main() lives
Bye!
1
demo Found in block in main() destroted

  7. 引发异常时编译器总是创建一个临时的拷贝，即使异常规范和catch块中指定的是引用，如下面的代码，catch将指向oops的副本，而不是oops本身，在释放函数内存后，oops将销毁，但是catch仍然使用引用，这是因为基类引用可以执行派生类对象，假设如果有一连串通过继承来关联的异常类型，则catch()中只需要写基类的引用，这将于任何派生类对象匹配，但是由于这种方法使得基类可以捕获派生类异常，一般catch语块排列顺序为将捕获位于层次结构最下面的异常类的catch语句放在最前面。

    ckass problem{...};
...
void super() throw(problem)
//函数原型后面写throw(xxx)提示使用super的话很可能会抛出什么类型异常
//如果throw的()里面没有东西，则意味着函数不会引发什么异常。
{
	if(oh_no)
	{
		problem oops;
		throw oops;
	}
}
...
try{
	super();
}
catch(problem& p)
{
	//statement;
}

    class bad_1{};
class bad_2:public bad_1{};
class bad_3:public bad_2{};
void duper()
{
	if(oh_no) throw bad_1();
	if(rats)  throw bad_2();
	if(drat)  throw bad_3();
}
try
{
	duper();
}
catch(bad_3& be)
{}
catch(bad_2& be)
{}
catch(bad_1& be)
{}
catch(...)
//这里可以使用省略号，类似于switch中的deflaut，可以捕获任何异常
{}

  8. 类型转换运算符:

    • dynamic_cast运算符:如果该运算符指向的对象(pt)类型为Type或者是从Type直接或者间接派生而来的类型，则下面的表达式将从指针pt转换为Type类型的指针,否则转化为空指针:dynamic_cast&ltType*&gt(pt),使用dynamic注意基类转换成派生类时，基类或者被基类继承的其他类需要一个virtual函数保证类时多态类型
    • typeid运算符:该运算符能够确定两个对象是否为同一个类型，可接受类名以及结果为对象的表达式，其返回的是type_info对象引用
    #include<iostream>
#include<typeinfo>
class Base
{
	virtual void Func(int a) { std::cout << a << std::endl; }
};
class Superb :public Base
{

};
class Magnificent :public Superb
{

};
int main()
{
	std::cout << typeid(Magnificent).name() << std::endl;
	Base* ptr1 = new Base;
	Base* ptr2 = new Superb;
	Base* ptr3 = new Magnificent;
	Superb* ptr4 = nullptr;
	if (ptr4 = dynamic_cast<Superb*>(ptr1))
	{
		std::cout << "Succeed for prt4 convert to ptr1" << std::endl;
	}
	else
	{
		std::cout << "Fail for ptr4 convert to ptr1" << std::endl;
	}
	if (ptr4 = dynamic_cast<Superb*>(ptr2))
	{
		std::cout << "Succeed for prt4 convert to ptr2" << std::endl;
	}
	else
	{
		std::cout << "Fail for ptr4 convert to ptr2" << std::endl;
	}
	if (ptr4 = dynamic_cast<Superb*>(ptr3))
	{
		std::cout << "Succeed for prt4 convert to ptr3" << std::endl;
	}
	else
	{
		std::cout << "Fail for ptr4 convert to ptr3" << std::endl;
	}
	if (typeid(1 + 3.0) == typeid(int))
	{
		std::cout << "Succeed for 1 + 2 convert to int" << std::endl;
	}
	else
	{
		std::cout << "Fail for 1 + 2 convert to int " << bool(typeid(1 + 3.0) != typeid(int)) << std::endl;
	}
	if (typeid(Magnificent) == typeid(*ptr3))
	{
		std::cout << "Succeed for Magnificent compare to *ptr2" << std::endl;
	}
	else
	{
		std::cout << "Fail for Magnificent compare to *ptr2" << std::endl;
	}
	delete ptr1;
	delete ptr2;
	delete ptr3;
	return 0;
}


    class Magnificent
Fail for ptr4 convert to ptr1
Succeed for prt4 convert to ptr2
Succeed for prt4 convert to ptr3
Fail for 1 + 2 convert to int 1
Succeed for Magnificent compare to *ptr2
  • const_cast用于将被const和volatile修饰的变量类型转换，const_cast&lttype-name&gt(expression),expression和type-name除了const和volatile特征可以不同外，二者类型必须相同。
    #include<iostream>
   #include<typeinfo>
   class Base
   {
   };
   class Superb :public Base
   {
   
   };
   class Magnificent :public Superb
   {
   
   };
   int main()
   {
   	Base base1;
   	const Base* base2 = &base1;
   	Base* ptr1 = const_cast<Base*> (base2);//valid
   	Base* ptr2 = (Base*)base2;//valid but dangerous
   	//const Superb* ptr2 = const_cast<const Superb*>(ptr1);//invalid 
   	return 0;
   }
  • static_cast&lttype-name&gt(expression)运算符仅当type_name可被隐式转换为expression所属的类型或者expression可被隐式转换为type_name所属类型时，上述转换才合法。
    #include<iostream>
#include<typeinfo>
class Base
{
};
class Superb :public Base
{

};
class Magnificent :public Superb
{

};
int main()
{
	Base* base1 = new Base;
	Superb* superb1 = new Superb;
	Magnificent* magnificent1 = new Magnificent;
	Base* base2;
	Superb* superb2;
	Magnificent* magnificent2;
	if (base2 = static_cast<Base*>(superb1))
	{
		std::cout << "Succeed for convert base2 to superb2" << std::endl;
	}
	else
	{
		std::cout << "Failed for convert base2 to superb2" << std::endl;
	}
	if (base2 = static_cast<Base*>(magnificent1))
	{
		std::cout << "Succeed for convert base2 to magnificent2" << std::endl;
	}
	else
	{
		std::cout << "Failed for convert base2 to magnificent2" << std::endl;
	}
	if (magnificent2 = static_cast<Magnificent*>(base1))
	{
		std::cout << "Succeed for convert magnificent2 to base1" << std::endl;
	}
	else
	{
		std::cout << "Failed for convert magnificent2 to base1" << std::endl;
	}
	if (magnificent2 = static_cast<Magnificent*>(superb1))
	{
		std::cout << "Succeed for convert magnificent2 to superb1" << std::endl;
	}
	else
	{
		std::cout << "Failed for convert magnificent2 to superb1" << std::endl;
	}
	delete base1;
	delete superb1;
	delete magnificent1;
	return 0;
}
  1. 构造函数初始化适用于初始化引用类型和const修饰的常变量,而且这两者都需要被类创建对象的时候初始化。
    class Exercise
{
private:
	int& a;
	const int b;
	int c;
public:
	Exercise(int x, int y, int z) :a(x), b(y), c(z) {};
};
北极星璇
关注
专栏目录
C++ Primer Plus学习笔记11-使用类
actually_ture的博客
12-21 202
1. 运算符重载 运算符重载是一种形式的C++多态。要重载运算符需要使用被称为运算符函数的特殊函数形式，格式如下： operatorop(argument-list) 如operator+(), operator*()。其中op必须是一个有效的C++运算符，不能虚构一个新符号。 比如，如果distrct2, sid和sara都是Salesperson类的对象，编写等式 district2 = sid + sara; 编译器发现，操作数是Salesperson类对象，因此使用相应的运算符函数替换上述运算符 d
《C++ Primer Plus（第六版）》（31）（第十五章 友元、异常和其他 笔记）
肥宝的实验室
12-29 2552
友元类，友元类函数，嵌套类，异常，运行时类型识别，type_id，type_info，各种转换 1.友元类，就在类中声明个friend class className；就行了。 这个是对所有成员有效的。 class A { public: A(int a){ _a = a; } friend class B; private: int _a; }; class B { public: int get(A a){ return a.
cpp primer plus笔记09-类
LEVIATHANq的博客
10-07 77
由于使用了默认复制构造函数，这使得(字符串)数组,赋值的时候使用的是a = b，而不是memcpy或者strcpy，从而会使得赋值变成复制数组地址，从而会使得被赋值的数组出现乱码，当赋值的数据被delete掉时，数组中的指针指向的数据会被delete掉，从而使得如果被赋值数据被delete掉时，会delete数据数据两次，引发异常。默认的复制构造函数会逐个复制非静态成员的值，如果成员本身是个类对象，则使用该成员的类的复制构造函数来复制成员对象，而静态成员不受影响。
cpp primer plus笔记010-继承
LEVIATHANq的博客
10-07 109
注：模板为不同类型的对象使用的类是不同的，如int的对象使用的int具体化的类，double的对象使用的是double具体化的类。如果定义了基类的指针或者引用，并且该指针和引用使用派生类构造或者赋值，如果调用一个基类和派生类都有的函数，如果基类同名函数没有被virtual修饰，则会调用基类的函数，否则调用派生类的函数。修饰类中的成员函数，如果基类中的的成员函数使用类virtual，则派生类可以重写基类的该成员函数。非约束模板友元，即友元的所有具体化都是类的每个具体化的友元。析构函数不能被继承。
C++Primer Plus笔记——第十五章 友元、异常和其他总结及程序清单
YukinoAI的博客
10-03 802
目录 本章小结 程序清单 友元类 15.1 tv.h                   15.2 tv.cpp                   15.3 use_tv.cpp            15.4 tvfm.h 嵌套类  15.5 queuetp.h         15.6 nested.cpp 异常 15.7 error1.cpp          15.8 e...
《C++ Primer Plus》第15章 友元、异常和其他 学习笔记
weixin_34021089的博客
07-14 115
友元使得能够为类开发更灵活的接口。类可以将其他函数、其他类和其他类的成员函数作为友元。在某些情况下，可能需要前向声明，需要特别注意类和方法声明的顺序，以正确地组合友元。潜逃类是在其他类中生命的类，它有助于设计这样的助手类，即实现其他类，单必须是共有接口的组成部分。C++机场机制为处理拙劣的编程事件，如不适当的I/O失败等，提供了一种灵活的方式。引发异常将终止当前值性的函数，将控制权传给匹配的cat...
C++ primer plus学习笔记 --- 第9章、内存模型和名称空间
qq_19432525的博客
05-06 173
单独编译是指将一个大型程序划分为多个源文件，并将这些源文件分别编译为单独的目标文件，再将这些目标文件链接为最终的可执行文件。使用单独编译可以简化程序的维护和管理，并提高代码的复用性和可读性。在 C++ 中，单独编译的工具是编译器和链接器。编译器负责将源代码编译为目标文件，而链接器负责将这些目标文件链接在一起，生成最终的可执行文件。在单独编译的过程中，开发人员需要合理编写头文件和源文件，以尽可能减小重复编译的次数，从而提高编译效率。在这个示例中，我们将Circle类的定义分别放在头文件Circle.h。
C++Primer Plus学习笔记
weixin_45068267的博客
04-08 2055
此博文是通过翻阅C++ Primer Plus中文第6版（2020），逐章学习记录笔记由此学习C++的基础特性和语法知识，有别于其它视频教学+代码+笔记的学习途径，更趋向传统的书籍+代码+笔记学习，Cpp第6版以C++11标准为主，学习C++基础编程绰绰有余.
C++ Primer Plus学习笔记12-类和动态内存分配
actually_ture的博客
12-23 290
友元函数重载运算符的bug 1. 动态内存和类 C++使用new和delete运算符动态控制内存。在类中使用这些运算符将导致许多新的编程问题。这种情况下，析构函数必不可少。 构造函数必须分配足够的内存来存储数据，然后再将数据复制到内存中。析构函数需要包含delete语句删除成员指针指向的内存。 当使用一个对象初始化另一个对象时，编译器自动生成复制构造函数，这个构造函数不知道需要更新类中自定义的静态变量，因此会将类的设计方案搞乱。 1.1 特殊成员函数 C++自动提供以下成员函数： 默认构造函数 默认析构函
C++Primer Plus笔记——第十五章 友元、异常和其他课后编程练习答案
YukinoAI的博客
10-04 367
课后编程练习答案 习题1                习题2               习题3             习题4 习题1 //tv.h #ifndef TV_H_ #define TV_H_ #include &lt;iostream&gt; using namespace std; class Tv { friend class Remote; public: ...
c++ Primer Plus笔记
margaret522的博客
07-10 626
1.使用原始的cin进行输入 cin在读取时，将忽略空格和换行符。只有在用户按下回车键后，输入的内容才会被发送给程序。 2.使用cin.get(char)进行补救
C++ Primer Plus 书之--C++ 嵌套类(内部类), 嵌套类访问权限
c1392851600的专栏
12-28 8141
嵌套类 在C++中, 可以将类声明放在另一个类中. 在另一个类中声明的类被称为嵌套类(nested class), 它通过提供新的类型类作用域来避免名称混乱. 包含类的成原函数可以创建和使用被嵌套类的对象; 而仅当声明位于共有部分, 才能在包含类的外面使用嵌套类, 而且必须使用作用域解析运算符. 对类进行嵌套和包含并不同, 包含意味着将类对象作为另一个类的成员, 而对类进行嵌套不创建类成员, ...
C++ primer plus学习笔记(三)——继承、虚函数、RTTI、友元类、异常、final
weixin_44627989的博客
04-01 606
上一篇博客简单提了继承，接下来继续学习继承这一章。 继承 前面讲到c++的继承是子类在继承时声明继承的权限，之前描述有点不够准确。以下时书中提及的能继承的成员。 当使用private继承时，父类的所有public成员在当前子类中会变为private。当使用protected继承时，父类的所有public成员在当前子类中会变为protected。。 虚函数 c++中，被定义为虚函数的成员，能被子类...
Window.history API学习笔记
常备不懈
11-12 662
在现代前端开发中，单页应用（SPA）的流行让我们对于页面的浏览历史管理需求愈加明显。`window.history` API作为浏览器提供的原生API，能够帮助开发者更加细致地控制用户的导航体验。本文将介绍`window.history` API的几个常见方法，并探讨它们的使用场景。
Spring学习笔记_32——事务TransactionStatus接口
LuckyLay的博客
11-12 299
TransactionStatus是Spring框架中用于表示事务状态的一个关键接口。它提供了一系列方法来查询和控制事务的执行状态，对于编程式事务管理尤为重要。TransactionStatus接口主要用来存储事务执行的状态，并且接口中定义了一组方法，用来判断或者读取事务的状态信息，
计算机网络详细笔记【湖科大教书匠，内含B站链接】
最新发布
qq_25467441的博客
11-14 301
https://blog.csdn.net/weixin_45488428/article/details/115102326?ops_request_misc=%257B%2522request%255Fid%2522%253A%252228292A6B-6BE1-4A80-BEA2-234F3AA87798%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=28292A6B-6BE1-4A80-BEA2-2
单片机学习笔记 Error:Device not found
qq_45151652的博客
11-11 795
（二）按“确定”之后打开Device查看，发现有89C52，但是没有CMS8S6990，想起最近将Keil卸了重新安装了，重新安装了CMS8S6990的库，说已经安装了。（一）将项目后缀名"uvproj"改成了"uvprojx"，还是报同样的错误。(三)打开别的工程并没有发现该问题，说明是工程的问题。重新新建一遍工程已解决。
Python 类私化有笔记
Katherine1029的博客
11-12 195
在开发中看到的一些私有化处理，装饰器@property，可以将私有化改成和非私有化一样的调用。#封装：1.私有化属性部分;2.定义共有的set和get方法。#__属性：就是将属性私有化，访问范围仅仅限于类中。2.也可以修改：通过set方法修改。1.隐藏属性不被外界修改。
Jdbc学习笔记（二）核心API--ResultSet
2301_76890677的博客
11-13 658
ResultSet默认只能往下移ResultSet表示结果集，它是一个二维的表格！ResultSet内部维护一个行光标（游标），ResultSet提供了一系列的方法来移动游标：void beforeFirst()：把光标放到第一行的前面，这也是光标默认的位置, 默认的结果集是无效的；void afterLast()：把光标放到最后一行的后面, 默认的结果集是无效的；boolean first()：把光标放到第一行的位置上，返回值表示调控光标是否成功, 默认的结果集是无效的；
C++primer Plus第2-13章编程练习答案详解
本资源摘要信息将对C++primer plus第2-13章的答案进行详细解读，涵盖了C++语言的基础知识和基本编程实践。 **第二章：开始学习C++** 本章节主要介绍了C++语言的基本概念和语法结构，包括变量、数据类型、运算符、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值