《高质量程序设计指南——C++/C》第三版勘误

《高质量程序设计指南——C++/C》第三版勘误

1．Page IX：1.5 “关于软件开发。。。”存在印刷问题；

2．Page 7：倒数第13行，“啰里啰唆”印刷有问题；

3．Page 15: 表1-2有些许印刷问题；

4．Page 58: 示例4-6，代码用下列代码替换：

class Base { private: int m_a; int m_b;	// 示例 Derived objD1; Base objB1 = objD1;      // 见图4-3左图 Derived *pD1 = &objD1;
}; class Derived : public Base { int m_c };	Base *pB1 = pD1;       // 见图4-3右图

 

5．Page 81：示例4-20中的注释/*第三条。。。*/修改为/*第二条。。。*/；

6．Page 83：在“最后我们举一个数值计算。。。。”一行前面插入“例5：数值计算。”；

7．Page 96: 示例6-1：将“T是形参”修改为“_T是形参”；

8．Page 181：[建议10-5]中，把“/t”修改为‘/t’；

9．Page 193: 示例12-3中少写了一句话，所以用下面的代码替换（红色表示修改的地方）：

typedef  unsigned char  BYTE;

template<unsigned int N  /*容量（字节数）*/>

class RingBuffer {

public:

    typedef size_t                       size_type;

    typedef GenericLocker<CriticalSection>  _BufferLocker;

    RingBuffer() : m_pushPos(0), m_popPos(0), m_count(0) {

assert(N > 0);

        m_pRingBuffer = new BYTE[N];

    }

    ~RingBuffer() { delete []m_pRingBuffer; }

    bool is_full() const {

        _BufferLocker guard(m_mutex);

        return (m_count == N);

    }

    bool is_empty() const {

        _BufferLocker guard(m_mutex);

        return (m_count == 0);

    }

    size_type size() const {

        _BufferLocker guard(m_mutex);

        return m_count;

    }

    size_type capacity() const { return N; }

    size_type push(const BYTE *data, size_type length) {

        _BufferLocker guard(m_mutex);

        assert(data != NULL);

        if (length == 0 || length > (N - m_count))

            return 0;

        size_type rearLen = N - m_pushPos;              // 尾部剩余空间

        if (length <= rearLen) {

            ::memmove(&m_pRingBuffer[m_pushPos], data, length);

            m_pushPos += length;

            m_pushPos %= N;                          // 调整新的push位置

        }else{

            ::memmove(&m_pRingBuffer[m_pushPos], data, rearLen);

            ::memmove(m_pRingBuffer, data + rearLen, length - rearLen);

            m_pushPos = length - rearLen;                // 调整新的push位置

            }

        m_count += length;

        return (length);

    }

    size_type pop(BYTE *buf, size_type length) {

        _BufferLocker guard(m_mutex);

        assert(buf != NULL);

        if (length == 0 || length > m_count)

            return 0;

        size_type rearLen = N - m_popPos;                // 尾部剩余数据

        if (length <= rearLen) {

            ::memmove(buf, &m_pRingBuffer[m_popPos], length);

            m_popPos += length;

            m_popPos %= N;                             // 调整新的pop位置

        }else {

            ::memmove(buf, &m_pRingBuffer[m_popPos], rearLen);

            ::memmove(buf + rearLen, m_pRingBuffer, length - rearLen);

            m_popPos = length - rearLen;                  // 调整新的pop位置

            }

        m_count -= length;

        return (length);

    }

    void clear() {

        _BufferLocker guard(m_mutex);

        m_pushPos = 0, m_popPos  = 0, m_count = 0;

    }

private:

    RingBuffer(const RingBuffer<N>&);

    void operator=(const RingBuffer<N>&);

private:

    BYTE          *m_pRingBuffer; // buffer

    size_type         m_pushPos;               // 新的push位置：pushPos=(popPos+count)% N

    size_type          m_popPos;             // 新的pop位置

    size_type         m_count;               // 有效字节数

    CriticalSection    m_mutex;

};

 

10．          Page 275：把[建议15-1]中的“比如反跟踪”修改为“（比如反跟踪）”；

11．          Page 309: 把“…必须派生自类似于接口IUnknown类”修改为“…必须派生自类似于接口IUnknown的类”；

12．          Page 343：示例17-7存在一个小问题，现用下面的代码替换（红色是修改过的地方）：

template<typename T  /*元素类型*/ , unsigned int N /*容量*/ >

class CyclicQueue {

public:

    typedef T                    value_type;

    typedef size_t                 size_type;

    typedef T&                   reference;

    typedef const T&              const_reference;

 

    CyclicQueue() : m_popPos(0), m_count(0) {

        assert(N > 0);

        m_beginPtr = (T*)(::operator new(sizeof(T) * N));  // 分配原始空间

        }

    ~CyclicQueue() {

        _Clear();                                              // this->_Clear();

        ::operator delete((void*)m_beginPtr);

        }

    CyclicQueue(const CyclicQueue<T, N>& copy) : m_popPos(0), m_count(0) {

        assert(N > 0);

        m_beginPtr = (T*)(::operator new(sizeof(T) * N));            // 分配原始空间

        size_t copyPos = copy.m_popPos;

        for (size_type idx = 0; idx < copy.m_count; ++idx) {

            _Copy(idx, copy.m_beginPtr[copyPos]);        // this->_Copy();

            ++copyPos; copyPos %= N; ++m_count;

            }

        }

    CyclicQueue& operator=(const CyclicQueue<T, N>& other) {

        CyclicQueue<T, N> temp(other);                                     // 调用拷贝构造函数

        _Swap(temp);                                   //  this->_Swap();

        return (*this);

        }

    bool is_empty() const { return (m_count == 0); }

    bool is_full() const { return (m_count == N); }

    value_type front() {

        assert(m_count != 0);

        return (m_beginPtr[m_popPos]);

        }

    value_type front() const {

        assert(m_count != 0);

        return (m_beginPtr[m_popPos]);

        }

    value_type back() {

return _Back();                                  // this->_Back();

        }

    value_type back() const {

return _Back();                                  // this->_Back();

        }

    bool push(const_reference data = T()) {

        if (m_count < N) {                                                          // 不满!

            size_type pushPos = (m_popPos + m_count) % N;

            _Copy(pushPos, data);                                      // this->_Copy();

            ++m_count;

            return true;

            }

        return false;

        }

    bool pop(reference data) {

        if (m_count > 0) {                                                           // 不空!

            data = m_beginPtr[m_popPos];                       // operator=

            _Destroy(m_popPos);                               // this->_Destroy();

            --m_count; ++m_popPos; m_popPos %= N;     // 新的pop位置

            return true;

            }

        return false;

        }

    size_type size() const { return m_count; }

    size_type capacity() const { return N; }

    void clear() { _Clear(); }                                     // this->_Clear();

    void swap(CyclicQueue<T, N>& other) {

        _Swap(other);                                   // this->_Swap();

        }

private:

    void _Clear() {

        for (; m_count > 0; --m_count) {

            _Destroy(m_popPos);                                         // this->_Destroy();

            ++m_popPos; m_popPos %= N;

            }

        m_popPos = 0;

    }   

    void _Destroy(size_type idx) {

        assert(idx < N);

        T *pTemp = (m_beginPtr + idx);

        pTemp->~T();                                      // 调用析构函数销毁元素对象

    }

    void _Copy(size_type idx, const_reference data) {

        assert(idx < N);

        T *pTemp = (m_beginPtr + idx);

        new ((void*)pTemp) T(data);  // 调用placement new和拷贝构造函数复制对象

    }

void _Swap(CyclicQueue<T, N>& other) {

        std::swap(m_beginPtr, other.m_beginPtr);

        std::swap(m_popPos, other.m_popPos);

        std::swap(m_count, other.m_count);

}

value_type _Back() const {

        assert(m_count != 0);

        size_type pushPos = (m_popPos + m_count) % N;

        if (pushPos == 0)

            return (*(m_beginPtr + N - 1));

        return (m_beginPtr[pushPos - 1]);

}

 

    value_type        *m_beginPtr;     // 队列存储空间起始位置

    size_type          m_popPos;        // 下次pop位置

    size_type          m_count;          // 有效元素个数

};

 

13．          Page 348：将“顾名思义”这一段第二行的“输出功能”改为“输入/输出功能”；

14．          Page 357：图17-12用图替换：

 

 

韩永泉

2007-6-18