qq_24328911的博客

关于区分接口继承和实现继承 开头，不说，这个程序对于现在基础薄弱的我，实在难得#include <iostream>#include <string>using std::string;using std::cout;如标题所言，class Shape {public: virtual void draw() = 0;//pure virtual fcn virtual v

#include <iostream>#include <iterator>#include <typeinfo>#include <vector>using namespace std;//way 1template <typename iterT, typename distT>void advance11(iterT it, distT d){ //random acc

#include <iostream>#include <string>using namespace std;//cout << ch;//我想定义这个 << 但union当时的值不缺定，遂没办法union Takon1{ friend ostream& operator<<(ostream &os, const Takon& take); char ch; int

关于new_handler,绝对是陌生的，想起之前放弃的MFC中的句柄的概念，觉得差不多，就是操作的new的一种工具，而那个句柄就是一个int，这个就是一个函数指针主意：c++不支持定义自己的new_handler,其实也没有必要，因为完全可以通过set_new_handlertypedef void (*new_handler)();//new_handler与之关系密切的 set_new_han

这两个程序一个样class Widget{public: static std::new_handler set_new_handler (std::new_handler p) throw();static void* operator new() throw(std::bad_alloc);private:std::new_handler currentHandler;};//st

直接上placement new 的定义： placement new ，如果new的参数接受一个参数以上的参数，那么它就是一个placement new ，但一般意义上的placement new ，只接受一个void*，用以使用vector分配但未使用的内存，该章节主要讲了一个log（志记功能）placement new ， 但是该条款的名字却是当你定义了一个placement new ，这

ADL:当编译器对无限定域的函数调用进行名字查找时，除了当前名字空间域以外，也会把函数参数类型所处的名字空间加入查找的范围no_throw 因为雷内特化，操作都是内置类型，更具体的在 item 25template <typename T>inline void swap(classname<T>& a, calssname<T>& b){ return a.swap(b);//调用类内

static （变量，函数，数据成员，函数成员）默认情况，一个对象或是变量被定义在所有块（block）之外，他拥有static的声明周期和外部连接（external linkage）静态的声明周期意味着变量在程序开始的时候被创建，在结束的时候被销毁，而外部连接意味着变量的名字在文件之外也是可见的，条件是：在该文件中该变量被声明过。相反的，内部链接意味着名字在文件外部不是可见的，即使该变量在那声明过

#include using namespace std;class A{public: A();private: ~A();};A::A(){}void main(){ // A a; 1 ctor必须有定义 2 只能用new创建对象 A* pa = new A;}考虑继承和内含#include using namespace std;class

#include using namespace std;/*判断某个对象是否在heap*/class A{public: A() ; class NoOnHeap; A(int ) { } static void* operator new(size_t size); void destroy() { delete this;}protected: //for B sta

#include <iostream>#include <fstream>#include <memory>#include <cstdio>using namespace std;class FileDtor{private: string filenames;public: FileDtor(string& name): filenames(name) { }

#include <iostream>#include <vector>#include <string>#include <queue>using namespace std;;void main(){ vector<int> a1{1}; queue<int> q1{1}; //but int x1(2.1);//ok int x2 = 2.1;//ok

#include <memory>#include <iostream>#include <vector>#include <string>using namespace std;void main(){ shared_ptr<string>pNico(new string("Nico")); shared_ptr<string>pJutta(new string("Jutt

我就是对swap为什么在类内定义一个成员函数，然后在外面定义一个非成员来调用它迷惑！ 我觉得我们的初衷是面对pimpl（指针实现的class）才去定义自己版本的swap。 而按照之前类的思想，类内函数，类外实现，类内调用类外也没差，错就错在这思想上，你现在做的工作是有个swap<>,当用它swap class,会先去找一个特例化的实现，由于是交换指针，而非对象，所以又进一步去调用成员swap，搜

这是我写的简易版的， Effective C++, 3rd Edition, Item 35: 考虑可选的 virtual functions（虚拟函数）的替代方法#include<iostream>//item 35using namespace std;/*------------------NVI--------------------*/class A{public: voi

#include <iostream>using namespace std;class empty{ //null};class A : private empty//这种情况下用private{ int s;};class AA { int s; empty e;};void main(){ empty e; A a; AA

#include <iostream>using namespace std;class A{//interface classpublic: virtual void f() = 0;//has no members shared_ptr<A> createA();//factory_fcn};shared_ptr<A> A::createA(){ //返回一个指针

#include <iostream>class A{public: void f1() { }//public 一般上都是接口，都是为了 is-a protected: void f2() { }//一般都是实现，//is-implemented-in-terms-ofprivate: void f3() { }//不能被B访问 virtual void f

#include <iostream>using namespace std;//zero objectclass CantBeInit{private: CantBeInit(); CantBeInit(const CantBeInit &);};//one objiectclass printer{public: void reset(); //voi

#include <iostream>using namespace std;class A{public: virtual void f() { cout << "A";}};class B: public A{public: void f() { cout << "B";}};void main(){ B b; A* pb = &b

#include <iostream>//virtual ctor// firstclass NLcomponent{public: virtual NLcomponent* clone() = 0; //...};class TextBlock : public NLcomponent{public: virtual TextBlock* clone() { }

#include <tuple>#include <iostream>#include <string>using namespace std;template <int IDX, int max, typename... Args>struct TUPLE_PRINT{ static void print(ostream& strm,const tuple<Args... >&

#include <iostream>/* >如果宇宙飞船以低速与太空站碰撞，宇宙飞船会泊进太空站（程序没有涉及） 否则宇宙飞船和太空站受到的损害与其速度成正比 >如果宇宙飞船与宇宙飞船碰撞，或是太空站与太空站碰撞，都会受损，受到的损害与其速度成正比 >如果小号的小行星与宇宙飞船或太空站相撞，小行星会损毁。如果碰到的是大号小行星， 那宇宙飞船或太空站损毁