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的博客-优快云博客 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的博客-优快云博客 书上例子可用下面的例子简单代替，即一个代表二维点的类，我们希望哪个这个点不可以被修改，所以只有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的博客-优快云博客） //*****************仅带函数无具体实现******************** #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的博客-优快云博客 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.662 int Global_Var_BB = 10; 比如定义如上两个变量，通过 g++ -g main.cpp readelf a.out -a > a.