zion--6135的博客

当operator new无法满足内存分配时，它会先调用错误处理函数new-handler，为了指定错误处理函数，客户必须调用set_new_handler()函数。 set_new_handler的简单用法：分配内存异常执行函数test()。#include <iostream>void test(){ std::cout << "okkk\n"; //会一直进入此函数}int main(){ std::set_new_handler(test);

1. 从属名称与非从属名称如果tempalte内某个名称依赖于某个template参数，我们称这个参数为从属名称(dependent names)比如C::const_iterator这个参数类型就是从属名称，依赖于C的类型。如果不依赖任何其他参数，称为非从属名称(non dependent names)这就是具体的，不依赖其他类型的参数类型：比如int ,float 这种具体的。2. 传递模板类型的从属名称参数需要在参数前加上typename传递带typename的参数：如p..

静态动态类型 参考：C++静态动态类型_zion--6135的博客-CSDN博客virtual函数是动态绑定的，但默认参数是静态绑定的#include <iostream>class A {public: virtual void test(int a = 10) { printf("====AA [%d]\n", a); }};class B:public A{public: virtual void test(int a = 1

待续--------std::function替代

impure virtual函数--继承接口+不强制实现 impure virtual函数可能的问题，参见下面的例子 class Airport {}; class Airplane {public: virtual void fly(const Airport& destination) { //飞机飞往指定的目的地 }}; //两种飞机class ModelA :public Airplane {};class ModelB ...

名称遮掩int x = 20; void someFunc(){ double x = 10.0; std::cout << x;]如上操作，函数打印结果是10.0还是20呢？是10.0。因为代码访问顺序是这样的，当需要变量x，现在someFun()函数里找，找不到x，再全局找x。本例：double x遮掩了int x继承中的名称遮掩 Derived类的调用作用域顺序 class Base{public: virtual v

最重要的一点：在public继承的时候：Derived is-a Base ; Base not is-a Derived Derived和Base的关系class Person {};class Student :public Person {};void eat(const Person& p);void study(const Student& s); int main(){ Person p; Student s; eat(p);.

搜了一下：不建议使用前置声明：如何看待C++前置声明？ - 知乎，所以重点讨论pimpl这种操作。 如果修改了某个class的实现，而依赖这个class有很多个文件，于是可能会出现修改了一点点代码，但编译需要很长的时间。这就是文件之间的依赖太多导致的。比如有这样一份代码：#include <string>#include "date.h"#include "address.h"class Person{private: std::string theName;...

一份不安全的代码，按照书上有如下例子void lock(Mutex* pm); void unlock(Mutex* pm); class PrettyMenu {public: void changeBackground(std::istream& imgSrc) { lock(&mutex); delete bgImage; ++imageChanges; bgImage = new I

C++的四种转换：参考C++的四种转换运算符_zion--6135的博客-CSDN博客 书上例子可用下面的例子简单代替，即一个代表二维点的类，我们希望哪个这个点不可以被修改，所以只有get函数，但若返回值为reference则有下面的问题返回值为reference​#include<iostream>#include<memory>using namespace std;class Point { //点public: Point(int x, in

变量不需要在函数开头定义，在用的时候定义就行了std::string encryptPassword(const std::string& password){ using namespace std; string encrypted; if (password.length()<MinimumPasswordLength) { throw logic_error("Password is too short"); }

待续：等比较熟悉template编程后再来看这里

基本的带operatr*的类函数（关于operatr在类里面的基本使用：operator重载_zion--6135的博客-CSDN博客）//*****************仅带函数无具体实现********************#include <iostream> using namespace std;class Rational{public: //构造函数未设置为explicit，因为我们希望一个int可以隐式转换为Rational Rational(i.

如果返回的对象为reference有什么问题有这样的有理数相乘的例子class Rational{public: Rational(int numerator = 0, int denominator = 1);private: int n, d; //分子和分母 // 返回对象为reference friend const Rational& operator*(const Rational& lhs, const Rational&.

值传递带来额外的开销，用引用可规避当值传递参数为一个Class对象class Person{public: Person(); virtual ~Person();private: std::string name; std::string address;}; class Student :public Person{public: Student(); ~Student();private: std::string school

share_ptr的构造函数是explict的void processWidget(std::shared_ptr<Widget> pw, int priority);processWidget(new Widget, priority());// 错误，因为shared_ptr构造函数是explict的，所以无法将 new Widget转换为shared_ptr<Widget>(new Widget)processWidget(std::shared_ptr&lt.

std::string* stringArray = new std::string; delete stringArray; //正确的//delete[] stringArray;错误的std::string* stringArray = new std::string[100]; //delete stringArray;错误的delete[] stringArray; //正确的new数组记得delete加上[]，否则会因为少delete了对象从而造成memory lea..

shared_ptr不等于shared_ptr的类型：如下面的例子：pInv是shared_ptr不是Investment*​#include <iostream>#include <memory>#include <mutex>// #include <pthread.h>using namespace std;class Investment {public: void printfxx() { std::cout.

以链接的例子为基础：C++资源管理_zion--6135的博客-CSDN博客class MutexLock{public: explicit MutexLock(pthread_mutex_t *_lock):lock_obj(_lock){ pthread_mutex_lock(lock_obj); } ~MutexLock(){ pthread_mutex_unlock(lock_obj); } private: p

一般的new/delete操作--不利于扩展，维护 //参照书本的new/delete操作示例class Investment {};void f(){ Investment* pInv = new Investment(); //... delete pInv;}这么做不会有问题，但不好，如果在//...处会return，或者其他操作导致未执行delete pInv;操作，会造成memory leak，这就引出了此条款，通过一个类去管理这new/dele..

在基类中构造函数中调用virtual函数带来不安全 #include <iostream>class Transaction {public: Transaction() { logTransaction(); } virtual void logTransaction() const = 0;};class BuyTransaction : public Transaction {public: virtual void logTrans..

放掉析构函数中的异常可能会导致程序崩溃class Widget{public: ~Widget() {} //假设这个析构函数可能会抛出异常}; int main(){ std::vector<Widget> v; return 0;}当main()函数执行结束会调用类Widget的析构函数，那如果这个vector里面有10个对象，需要调用析构函数10次，如果第一个对象调用析构函数的时候有的异常没处理，程序之后可能会有很多问题。所以别让异常逃离析构

通过用户去调用工厂方法创建对象，然后delet是不安全的---见条款13 如何修改factory函数避免调用的错误？---见条款18 删除指向派生类的基类对象指针可能带来内存泄漏。 删除指向派生类的基类对象，只会调用基类析构函数。#include <iostream>using namespace std; class Base{ public: ~Base() {cout<<"~B"<<endl;}}; class Der..

正如条款5，编译器有一些默认构造，赋值函数。但在某种情况下，我们不希望这个类的对象可以被拷贝，所以需要明确的拒绝这些默认构造，赋值函数的生成。编译器产生的default函数都是public的 通过private+函数空实现防止这个类被拷贝，复制。 通过自定义 拷贝函数 && 构造拷贝函数 来防止编译器自动生成，通过设置此函数为private来避免被类外对象调用。class Empty{public: Empty() {/******/} ~Empty.

常见的默认构造函数，默认拷贝构造，默认拷贝赋值运算 #include <iostream>using namespace std;class Empty{}; //空类int main(){ Empty e1; //调用e1的默认构造函数 Empty e2(e1);//调用e2的默认拷贝构造函数 e2 = e1; //调用e2的默认拷贝赋值运算符 return 0;}当在main中有如上代码，类Empty中什么都没有写，但main中却可以调...

C++的变量初始化顺序时有先后的，比如下面的例子中的n1,n2 #include <iostream>using namespace std; class A{public: A() :n2(0), n1(n2 + 2) {} void print() { cout << "n1:" << n1 << " , n2:" << n2 << endl; }private: int n1;..

const修饰指针，变量（通过const的位置知道限定指针还是变量） 常量指针（const int* a; 或int const* a;）：常量在前，指针在后，故称之常量指针。const限定的是 *a , 代表值不可修改。a并没有被const限制，代表指针可以修改。就如下面例子。const int* a; //等同于 int const* a;int b =10;a = &b ; //正确，指针可以修改*a = b; //错误，值不可修改指针常量（int* const..

众所周知：代码编译为四个步骤：预编译-->编译--->汇编--->链接而#define是预编译过程处理的东西，而const,enum,inline是编译过程处理的东西。尽量用const, enum, inline替换#define这句话也可以说：编译优于预编译。#define Global_Var_AA 10.662int Global_Var_BB = 10;比如定义如上两个变量，通过g++ -g main.cppreadelf a.out -a > a.