stevenzhou的专栏

/* trie的节点类型 */template //Size为字符表的大小struct trie_node {bool terminable; //当前节点是否可以作为字符串的结尾int node; //子节点的个数trie_node *child[Size]; //指向子节点指针/* 构造函数 */trie_node() : terminable(false

void* Memcpy(void *p, void *p1,size_t count){    assert(p && p1);     char *pDest = static_cast(p); char *pSrt = static_cast(p1); while(count--) {  *pDest++ = *pSrt++ ; }  return pDest;}void *Me

I l@ve RuBoard Item 29. Compilation Firewalls Difficulty: 6 Usi

I l@ve RuBoard Item 30. The "Fast Pimpl" Idiom Difficulty: 6 It

Difficulty: 9½When you call a function, which function do you call? The answer is determined by name lookup, but youre almost certain to find some of the details surprising.In the following code,

Difficulty: 9Whats in a class? That is, what is "part of" a class and its interface?Hint #1: Clearly nonstatic member functions are tightly coupled to the class, and public nonstatic member funct

Difficulty: 5Take a few minutes to consider some implications of the Interface Principle on the way we reason about program design. Well revisit a classic design problem: "Whats the best way to wr

How well do you know memory? What different memory areas are there?This problem covers basics about C++s main distinct memory stores. The following problem goes on to attack some deeper memory mana

Difficulty: 8This Item covers basics about how you can use the standard auto_ptr safely and effectively.Historical note: The original simpler form of this Item, appearing as a Special Edition of G

This first problem highlights the importance of understanding what you write. Here we have four simple lines of code, no two of which mean the same thing, even though the syntax varies only slightly.

Item 46. Forwarding FunctionsDifficulty: 3Whats the best way to write a forwarding function? The basic answer is easy, but well also learn about a subtle change to the language made shortly befo

ForewordThis is a remarkable book, but it wasnt until I had nearly finished reading it that I realized just how remarkable it is. This could well be the first book ever written for people who are a

是的，我们同意C语言中变量要放在模块头部定义的规定；但在C++中，还是取消这种做法吧，它没必要，不自然，而且昂贵。还记得吗？如果定义了一个有构造函数和析构函数的类型的变量，当程序运行到变量定义之处时，必然面临构造的开销；当变量离开它的生命空间时，又要承担析构的开销。这意味着定义无用的变量必然伴随着不必要的开销，所以只要可能，就要避免这种情况发生。正如我所知道的，你的编程方式优雅而不失老练。

I l@ve RuBoard Item 27. Minimizing Compile-time Dependencies桺art 2 Difficult

We conclude this miniseries by considering some implications of the Interface Principle on name lookup. Can you spot the (quite subtle) problem lurking in the following code? What is na

C++ 是一种通用的程序设计语言，特别是面向系统程序设计它是：1。是一个更好的C2。支持数据抽象3。支持面象对向的程序设计4。支持通用型程序设计

sprintf 优缺点：1。易用性与清晰性     2。效率最佳 ，通过使用sprintf 将结果直接放到一个已有的缓冲区中3。长度不安全4。类型不安全6。不可以在模板中使用建议：永远不要使用sprintf 代替方案（std::ostringstream  boost::lexical_cast)void Test(string&s, int i){   o

1. C++ 中主要有哪两种形式的模板，它们分别如何进行特化?    C++中有类模板与函数模板之分。这两种模板的工作方式并不完全一样，最明显的区别在于重载，普通C++类是不能重载的，因此类模板也不能够重载。另一方面，普通的C++函数如果名字相同（且函数签名不同）就会发生重载，因而函数也允许重载。 此外类模板可以被偏特化或全特化。函数模板则只能被全特化，不过，由于函数模板可以被重载，所以我们通

//快速排序int PARTITION(int array[],int p,int r){     int x = array[r];    int i = p - 1;for(int j = p; j {if (array[j] {++i;swap(array[i],array[j]);}}swap(array[i + 1],array

#include "stdafx.h"#include #include using namespace std;using namespace boost;/*** 合并两个排好的序列* @param A* int数组* @param p* 起始位置* @param q* 中间位置* @param r* 终止位置* @param

int main(){int a[10] = {7,2,5,1,6,9,4,8,0,3};for(int i = 1; i {int iKey = a[i];int j = i - 1;while(j >= 0 && a[j] > iKey){a[j + 1] = a[j];--j;}a[j +1] = iKey;}f

int main(int argc, const char* argv[]){vector v;v.push_back(1);v.push_back(2);v.push_back(3);vector::iterator iterBeg = v.begin();vector::iterator iterEnd = v.end();while(iterBeg != v.end()){iterBeg = v.erase(iterBeg);}vector().swap(v);system("pause");retu

<br />当关乎效率时应该在map::operator[]和map-insert之间仔细选择<br /><br />class Widget {<br />public:<br />Widget();<br />Widget(double weight);<br />Widget& operator=(double weight);<br />...<br />}<br /><br />map<int, Widget> m;<br />m[1] = 1.50;<br /> <br /><br />表达式m

void Int64ToByte(BYTE *pData){ BYTE *pBegin = pData; BYTE *pEnd  = pData + 7;     for (int i= 0; i  {  BYTE temp;  temp = *pBegin;  *pBegin = *pEnd;  *pEnd = temp;    ++pBegin;  --pEnd; }} 

bool IsHalfUnicode(CString strText){  const char* szStrText = (LPCTSTR)strText;  LPCTSTR  p=  szStrText;    int nCount = 0;  int nFonts = strText.GetLength();  int nUnicode = 0;  //是否为偶数个数  int nEve

void ConvertGBKToUtf8(CString& strGBK) {    int len=MultiByteToWideChar(CP_ACP, 0, (LPCTSTR)strGBK, -1, NULL,0);    unsigned short * wszUtf8 = new unsigned short[len+1];    memset(wszUtf8, 0, len * 2

bool FileExists(LPCTSTR lpszFileName, bool bIsDirCheck){ DWORD dwAttributes = GetFileAttributes(lpszFileName);    if(dwAttributes == 0xFFFFFFFF) {        return false; } if((dwAttributes & FILE_ATTR

void Printf(char*str...){    va_list list; int intType; char* charType; float floatType; char* curType = str; va_start(list,str); while( 0 != *curType) {  switch(*curType)  {  case d:   intTyp

一个指向任何对象 类型的指针都可以赋值给类型为void* 的变量，void* 可以赋值给另一个void* ，两个void* 可以比较相等与否，而且可以显式地将void* 转换到另一个类型。其它操作都是不安全的，因为编译器并不知道实际被指的是哪种对象。因此，对void* 做其他任何操作都将引起编译错误。要使用void*,就必须显式地将经转换到某个指向特定类型的指针。例：void  Test(

struct Pair{ string name; double val;};vectorpairs;double& value(const string&s){ for(int i = 0; i   if( s == pairs[i].name) return pairs[i].val; Pair p = {s,0}; pairs.push_back(p); return pai

#include#include#include#include#includeusing namespace std;int main(){ string from,to;  cin>>from>>to; ifstream ifs(from.c_str()); istream_iteratorii(ifs); istream_iteratoreos; vectorv; c

When using iterators, be aware of four main issues. Valid values: Is the iterator dereferenceable? For example, writing "*e.end()" is always a programming error. Valid li

Are you thinking about doing your own class-specific memory management, or even replacing C++s global new and delete? First, try this problem on for size.The following code shows classes that perfo

请看面向对象世界里发生的一幕：对象a：亲爱的，永远别变心！对象b：别担心，亲爱的，我是const。然而，和现实生活中一样，a会怀疑，"能相信b吗？" 同样地，和现实生活中一样，答案取决于b的本性：其成员函数的组成结构。假设b是一个const string对象：class string {public:  string(const char *value);        // 具体

做类似下面的事时，就会发生自己给自己赋值的情况：class x { ... };x a;a = a;                     // a赋值给自己这种事做起来好象很无聊，但它完全是合法的，所以看到程序员这样做不要感到丝毫的怀疑。更重要的是，给自己赋值的情况还可以以下面这种看起来更隐蔽的形式出现：a = b;如果b是a的另一个名字（例如，已被初始化为a的

条款45说明了如果没写赋值运算符的话，编译器就会为你生成一个，条款11则说明了为什么你会经常不喜欢编译器为你生成的这个赋值运算符，所以你会想能否有个两全其美的办法，让编译器生成一个缺省的赋值运算符，然后可以有选择地重写不喜欢的部分。这是不可能的！只要想对赋值过程的某一个部分进行控制，就必须负责做赋值过程中所有的事。实际编程中，这意味着写赋值运算符时，必须对对象的每一个数据成员赋值：temp

看这样一个模板，它生成的类使得一个名字和一个t类型的对象的指针关联起来。templateclass namedptr {public:  namedptr(const string& initname, t *initptr);  ...private:  string name;  t *ptr;};（因为有指针成员的对象在进行拷贝和赋值操作时可能会引起指针混乱（见条款11），nam

// TEMPLATE FUNCTION transform WITH UNARY OPtemplate inline _OI transform(_II _F, _II _L, _OI _X, _Uop _U) {for (; _F != _L; ++_F, ++_X)  *_X = _U(*_F); return (_X); }  // TEMPLATE FUNCTION transform

template inline _Fn for_each(_II _F, _II _L, _Fn _Op) {for (; _F != _L; ++_F)  _Op(*_F); return (_Op); }  // TEMPLATE FUNCTION findtemplate inline _II find(_II _F, _II _L, const _Ty& _V) {for (; _F !=

class GenericStack{protected:  GenericStack():top(0){}  virtual ~GenericStack()  {   while(top)   {    Data *temp = top;    top = top->next;    delete temp;   }   top = 0;  }  void push(void *value)