在C++项目中，一些场景下，可能会用到一个空的日志类，覆盖项目中的日志实现，让项目不打印日志，比如：

• 屏蔽某个类库中的日志（因为库的日志打印机制设计的不够好）
• 单例测试中代码中，屏蔽项目日志

应对以上需求，本文实现了一个不打印日志的类，有如下特点：

• 覆盖项目中日志的宏定义，比如LOG_INFO等，不打印日志
• 重载operator<<操作符的实现

实现中有哪一些陷阱呢？主要在std::endl上面。

在重载operator<<操作符的时候，使用LOG_INFO<<"log"<<std::endl; 时，会提示，std::endl是未知类型（unresolved overloaded function type）

关于std::endl的本质，是一个函数模板，本文不做详细阐述，只给出实现方法。

代码如下，使用c++11标准实现：

#ifdef DISABLE_PRJ_LOG

#undef LOG_DEBUG
#undef LOG_INFO
#undef LOG_WARN
#undef LOG_ERROR
#undef LOG_FATAL

#include 
#include 

class BlankLogObject {
public:
    static BlankLogObject& Ins() {
        static BlankLogObject obj;
        return obj;
    }
    BlankLogObject& operator<<(void* in) { return *this; }
    BlankLogObject& operator<<(char in) { return *this; }
    BlankLogObject& operator<<(const char* in) { return *this; }
    BlankLogObject& operator<<(const std::string& in) { return *this; }
    BlankLogObject& operator<<(int16_t in) { return *this; }
    BlankLogObject& operator<<(int32_t in) { return *this; }
    BlankLogObject& operator<<(uint32_t in) { return *this; }
    BlankLogObject& operator<<(int64_t in) { return *this; }
    BlankLogObject& operator<<(uint64_t in) { return *this; }
    BlankLogObject& operator<<(float in) { return *this; }
    BlankLogObject& operator<<(double in) { return *this; }
    BlankLogObject& operator<<(BlankLogObject& in) { return *this; }
    BlankLogObject& operator<<(std::ostream& in) { return *this; }
    BlankLogObject& operator<<(std::ostream (*in)(std::ostream&)) { return *this; }

    typedef std::basic_ostream > endl_type;
    BlankLogObject& operator<<(endl_type& (*in)(endl_type&))  { return *this; }
};
}

#define LOG_DEBUG rec::BlankLogObject::Ins()
#define LOG_INFO  rec::BlankLogObject::Ins()
#define LOG_WARN  rec::BlankLogObject::Ins()
#define LOG_ERROR rec::BlankLogObject::Ins()
#define LOG_FATAL rec::BlankLogObject::Ins()
#endif
int main() {
    LOG_INFO << "skf" << 123 << 0.1 << std::endl;
    return 0;
}

梗概

已知 C++ 11禁止使用COW，本文进行验证。

测试代码

#include 
#include 
#include

int main() {
    std::string origin("cow\n");
    std::string copy( origin);

    printf(origin.c_str());
    printf(copy.c_str());
    printf("origin\taddress is %x\n",(int64_t)origin.c_str());
    printf("copy\taddress is %x\n",(int64_t)copy.c_str());
    copy[0] = 'w';
    printf(origin.c_str());
    printf(copy.c_str());
    printf("origin\taddress is %x\n",(int64_t)origin.c_str());
    printf("copy\taddress is %x\n",(int64_t)copy.c_str());
    return 0;
}

使用gcc 6.3.0测试

$ g++ -o cow cow.cpp --std=c++98

$ ./cow
cow
cow
origin  address is 8c69cc40
copy    address is 8c69cc20
cow
wow
origin  address is 8c69cc40
copy    address is 8c69cc20

$ g++ -o cow cow.cpp --std=c++11
$ ./cow
cow
cow
origin  address is 28240270
copy    address is 28240250
cow
wow
origin  address is 28240270
copy    address is 28240250

使用gcc 4.8.5测试

$ g++ -o cow cow.cpp --std=c++98
$ ./cow
cow
cow
origin  address is aa9028
copy    address is aa9028
cow
wow
origin  address is aa9028
copy    address is aa9058

$ g++ -o cow cow.cpp --std=c++11
$ ./cow
cow
cow
origin  address is 23a0028
copy    address is 23a0028
cow
wow
origin  address is 23a0028
copy    address is 23a0058

结论

从gcc的实际的实现看，cow 并非是c++11之后禁止的，而是从gcc的某个版本开始禁止cow机制，与c++11无必然关系。

brpc自适应限流的一个bug

• brpc 会不断尝试调小 max_concurrency， 然后重新计算
• 因为上面的原因，当qps比较低时，max_concurrency会被计算的非常小
• 一旦面临流量的突增，即便在机器的负载范围内，但因为超过max_concurrency，而返回限流的错误
• 紧接上一条，即便客户端重试发送别的机器，因为下游服务整体max_concurrency，依然会接收限流的错误。

结论 brpc的自适应限流，只适合大流量，且流量稳定的场景。不适合小流量的服务。

无锁栈实现原理

本文是用过C++11标准下的原子变量atomic的CAS操作compare_exchange_weak，来实现无锁栈（Lock-free Stack）。

• 通过compare_exchange_weak方法，来实现栈顶元素添加操作的原子性。
• 栈内元素都会由Node数据结构封装，可以规避CAS操作的ABA问题。

无锁栈实现编码

#ifndef LOCK_FREE_STACK_HPP
#define LOCK_FREE_STACK_HPP

#include 

template
class LockFreeStack {
public:
    struct Node {
        Node() : data(nullptr), pre(nullptr) {}
        void reset() { data = nullptr; pre = nullptr;}

        T *data;
        Node* pre;
    };

    LockFreeStack() : count(0), back(nullptr) {}
    ~LockFreeStack() { clear(); }

    void push(const T* data) {
        Node* node = alloc();
        node->data = const_cast(data);
        for (;;) {
            node->pre = back;
            if (back.compare_exchange_weak(node->pre, node, std::memory_order_seq_cst) ) {
                break;
            } else {
                continue;
            }
        }
        ++count;
    }

    T* pop() {
        for (;;) {
            Node* back_node = back;
            if (nullptr == back_node) { return nullptr; }
            Node* second_node = back_node->pre;
            if(!back.compare_exchange_weak(back_node, second_node, std::memory_order_seq_cst)) {
                continue;
            } else {
                --count;
                T* data = back_node->data;
                recycle(back_node);
                return data;
            }
        }
    }
    bool empty() { return (bool)count; }
    int64_t size() { return count; }
    void clear() { while (nullptr != pop()) {}; }

private:
    Node *alloc() { return (new Node()); }
    void recycle(Node *node) { delete node; }

    std::atomic count;
    std::atomic back;
};
#endif

They say a good example is worth 100 pages of API documentation, a million directives, or a thousand words.

最近项目中决定使用Google的C++代码规范，然后写了两个代码示例文件(.h 和 .cc)，这两个文件中的代码都是用Google的C++代码规范。

写示例代码的好处

• 减少查看文档时间，降低学习成本
• 帮助程序员快速了解Google的代码风格的概貌
• 用于参考和模仿，帮助快速上手

代码托管地址

下面地址保持持续更新：

https://github.com/zuocheng-liu/code-samples/tree/master/code_style

仓促之作，错误和疏忽不可避免，但保证后续不断更新。

初版代码示例

建议点击上面的链接，获取最新版。编辑器的原因，缩进的显示可能有问题。

// Copyright (c) 2016, Zuocheng.net
//
// Author: Zuocheng Liu
//
// Lisence: GPL
//
// File: code_samples/code_style/google_code_style.h 
// (文件名要全部小写，可以包含下划线（_）或短线（-）)
// C++文件以.cc 结尾，头文件以.h 结尾。
//
// Google C++ code Style 代码示例 (简体中文版)
//
// *注释  使用//或/* */，但要统一。
// *注释  每一个文件版权许可及作者信息后，对文件内容进行注释说明
// -------------------------------------------------------------最多不能超过80行
#ifndef CODE_SAMPLES_CODE_STYLE_GOOGLE_CODE_STYLE_
#define CODE_SAMPLES_CODE_STYLE_GOOGLE_CODE_STYLE_
// 命名空间的名称是全小写的，其命名基于项目名称和目录结构
// 不要声明命名空间std 下的任何内容
namespace code_samples {
namespace code_style {

// **变量命名**
// 尽可能给出描述性名称，不要节约空间
// 变量名一律小写，单词间以下划线相连
// 少用全用变量，可以以g_与局部变量区分
int g_my_exciting_global_variable;

// 只有在描述数据时用struct ，其他情况都用class
typedef struct CodeStyle {
    uint32_t type;
} CodeStyle;

// **类注释** 
// 每个类的定义要附着描述类的功能和用法的注释
//
// GoogleCodeStyle , 通过代码示例，展现google c++ code style
//
// (按需注明synchronization assumptions，是否线程安全)
class GoogleCodeStyle {
public :

  // ** 声明次序 **
  // - typedefs 和enums；
  // - 常量；
  // - 构造函数；
  // - 析构函数；
  // - 成员函数，含静态成员函数；
  // - 数据成员，含静态数据成员。

  // **类型命名**
  // 每个单词以大写字母开头，不包含下划线
  // 所有类型命名——类、结构体、类型定义（typedef）、枚举——使用相同约定
  typedef enum StyleType {
      // 枚举值应全部大写，单词间以下划线相连
      GOOGLE_CODE_STYLE = 0,
      K_AND_R,
      POCO
  } StyleType;

  // 常量命名，在名称前加k
  const int kDaysInAWeek = 7;   

  GoogleCodeStyle() {}
  ~GoogleCodeStyle() {}
  // **函数注释**
  // 函数声明处注释描述函数功能，定义处描述函数实现.
  // - inputs（输入）及outputs（输出）；
  // - 对类成员函数而言：函数调用期间对象是否需要保持引用参数，是否会释放这些参数；
  // - 如果函数分配了空间，需要由调用者释放；
  // - 参数是否可以为NULL；
  // - 是否存在函数使用的性能隐忧（performance implications）；
  // - 如果函数是可重入的（re-entrant），其同步前提（synchronization assumptions）
  // 举例 ：
  // 初始化函数
  ~Init() {}

  // 普通函数名以大写字母开头，每个单词首字母大写，没有下划线
  // 
  uint32_t MyExcitingMethod(CodeStype &code_style, char *output);
  // 存取函数要与存取的变量名匹配
  inline int num_entries() const { return num_entries_; }
  inline void set_num_entries(int num_entries) { num_entries_ = num_entries; }

  // 类的成员变量以下划线结尾
  int num_completed_connections_;

protected :

private :
  // **类数据成员**
  // 每个类数据成员（也叫实例变量或成员变量）应注释说明用途。
  // 如果变量可以接受NULL 或-1, 等警戒值（sentinel values），须说明之
  int num_entries_;

}; // class GoogleCodeStyle

}} // namespace code_samples::code_style 

#endif //CODE_SAMPLES_CODE_STYLE_GOOGLE_CODE_STYLE