yukuaishi的专栏

#include using std::vector; int main() { vector e; copy(istream_iterator(cin), istream_iterator(), back_inserter(e)); // the find() algorithm returns its second argument(e.end()) if the value i

class Complex { public: // The constructor allows an implicit conversion. // Watch out for hidden temporaries created by implicit conversions. explicit Complex(double real, double imaginary = 0)

auto_ptr source() { return auto_ptr( new T(1) ); } void sink( auto_ptr pt ) { } void f() { auto_ptr a( source() ); sink( source() ); sink( auto_ptr( new T(1) ) ); // It is never safe t

class B { public: virtual ~B(); void operator delete (void*, size_t) throw(); void operator delete[](void*, size_t) throw(); void f(void*, size_t) throw(); }; class D : public B { pub

Use inheritance wisely. If you can express a class relationship using containment/delegation alone, you should always prefer that. If you need inheritance but aren't modeling IS-A, use nonpublic inher

T t; T t(); T t(u); T t = u; // T t(T(u)); // When using return-by-value for non-builtin return types, prefer returning a const value. typedef int bool; const bool true = 1; const bool fals

// x.h: original header // #include // remove, unnecessary #include // std, typedef. it can replace with #include #include // for compatibility. #include // None of A, B, C, D or E are t

// In C++, when anything in a class definition changes (even private members), // all users of that class must be recompiled. To reduce these dependencies, // a common technique is to use an opaque

// file y.h class X; class Y { /*...*/ X* px_; }; // file y.cpp #include "x.h" Y::Y() : px_( new X ) {} Y::~Y() { delete px_; px_ = 0; } // This nicely hides X, but it turns out that Y is u

namespace A { struct X; struct Y; void f( int ); void g( X ); } namespace B { void f( int i ) { f( i ); // which f()? } void g( A::X x ) { g( x ); // which g()? }

Prefer using the free store (new/delete). Avoid using the heap (malloc/free). const data stack free store Heap global/static

// Example 2: Will this compile? // // In some library header: namespace N { class C {}; } int operator+(int i, N::C) { return i+1; } // solution this problem: let operator in N // A mainline to exer

/* ci_string s( "AbCdE" ); // case insensitive // assert( s == "abcde" ); assert( s == "ABCDE" ); // still case-preserving, of course // assert( strcmp( s.c_str(), "AbCdE" ) == 0 ); assert( strcm

template class fixed_vector { public: typedef T* iterator; typedef const T* const_iterator; iterator begin() { return v_; } iterator end() { return v_+size; } const_iterator begin() c

// 1.invokes the Employee copy constructor. This copy operation might throw an exception String EvaluateSalaryAndReturnName(Employee e) { // 2.The Title() member function might itself throw, or it

template class Stack { public: Stack(); ~Stack(); Stack(const Stack& other); Stack& operator=(const Stack& other); size_t Count() const; void Push(const T&); // T* Pop(); void Pop(); T* T

template class Stack { public: Stack(); ~Stack(); Stack(const Stack& other); Stack& operator=(const Stack& other); size_t Count() const; void Push(const T&); // T* Pop(); void Pop(); T* T

string FindAddr(list emps, string name) // const &, string& dangerous. { // for most containers, calling end() returns a temporary object that must be constructed and detroyed. for(list::iterator i

#include #include using namespace std; class Base { public: virtual void f( int ); virtual void f(double); virtual void g(int i = 10); }; void Base::f( int ) { cout << "Base::f(int)" <<

class BasicProtocol /* : possible base classes */ // MessageCreator or MessageHelper. { public: BasicProtocol(); virtual ~BasicProtocol(); bool BasicMsgA( /*...*/ ); bool BasicMsgB( /*...*/

class GenericTableAlgorithm { public: GenericTableAlgorithm(const string& table); virtual ~GenericTableAlgorithm(); // Process() returns true if and only if successful. // It does all the wor

//*** Example 5 (a) -- nonvirtual streaming class X { /*...ostream is never mentioned here...*/ }; ostream& operator<<( ostream& o, const X& x ) { /* code to output an X to a stream */ return o;