Caffe 源码中的C++细节点
宏定义define
class LayerRegisterer {
public:
LayerRegisterer(const string& type,
shared_ptr<Layer<Dtype> > (*creator)(const LayerParameter&)) {
// LOG(INFO) << "Registering layer type: " << type;
LayerRegistry<Dtype>::AddCreator(type, creator);
}
};
#define REGISTER_LAYER_CREATOR(type, creator) \
static LayerRegisterer<float> g_creator_f_##type(#type, creator<float>); \
static LayerRegisterer<double> g_creator_d_##type(#type, creator<double>) \
//宏声明时以 反斜线 “\” 进行换行
#define REGISTER_LAYER_CLASS(type) \
template <typename Dtype> \
shared_ptr<Layer<Dtype> > Creator_##type##Layer(const LayerParameter& param) \
{ \
return shared_ptr<Layer<Dtype> >(new type##Layer<Dtype>(param)); \
} \
REGISTER_LAYER_CREATOR(type, Creator_##type##Layer)
在宏体中，如果宏参数前加个#，那么在宏体扩展的时候，宏参数会被扩展成字符串的形式。此处的 #type 将被扩展成字符串。
在宏体中，如果宏体所在标示符中有##，那么在宏体扩展的时候，宏参数会被直接替换到标示符中。例如此处的 ##type，将以字符串的形式与 g_creator_f_ 连接。
使用宏 字符串化 使得代码具有良好的通用性，例如：
REGISTER_LAYER_CREATOR(Convolution, GetConvolutionLayer);
会被扩展成：
LayerRegisterer<double> g_creator_d_Convolution("Convolution", GetConvolutionLayer)
还有一个 template <typename Dtype> 类型模板，在caffe中还是使用比较频繁的，使得类的通用行更强。
关键字 explicit 使用
C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的, 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式)。
caffe中使用关键字 explicit：
template <typename Dtype>
class ConvolutionLayer : public BaseConvolutionLayer<Dtype> {
public:
explicit ConvolutionLayer(const LayerParameter& param): BaseConvolutionLayer<Dtype>(param) {}//子类显示调用父类类构造函数做，并且子类类构造函数仅有一个参数
virtual inline const char* type() const { return "Convolution"; }// virtual关键字用于在父类中声明一个可重载的成员函数，即在其子类(继承类）可以再次声明相同的成员函数，并且在调用时可以选择是调用子类还是父类，如果不加virtual关键字，则只会选择调用父类成员函数。
ConvolutionLayer 类的构造函数显示调用了父类类构造函数，并且只有一个参数。
显示声明的构造函数和隐式声明的有什么区别如下：
class CxString // 没有使用explicit关键字的类声明构造函数, 即默认为隐式声明（仅有一个参数)
{
public:
char *_pstr;
int _size;
CxString(int size)
{
_size = size; // string的预设大小
_pstr = malloc(size + 1); // 分配string的内存, malloc申请一个堆内存
memset(_pstr, 0, size + 1); // memset作用是将 size + 1大小的_pstr内存赋值0
}
CxString(const char *p)
{
int size = strlen(p);
_pstr = malloc(size + 1); // 分配string的内存
strcpy(_pstr, p); // 复制字符串
_size = strlen(_pstr);
}
// 析构函数这里不讨论, 省略...
};
// 下面是调用:
CxString string1(24); // 这样是OK的, 为CxString预分配24字节的大小的内存
CxString string2 = 10; // 这样是OK的, 为CxString预分配10字节的大小的内存
CxString string3; // 这样是不行的, 因为没有默认构造函数, 错误为: “CxString”: 没有合适的默认构造函数可用
CxString string4("aaaa"); // 这样是OK的
CxString string5 = "bbb"; // 这样也是OK的, 调用的是CxString(const char *p)
CxString string6 = 'c'; // 这样也是OK的, 其实调用的是CxString(int size), 且size等于'c'的ascii码
string1 = 2; // 这样也是OK的, 为CxString预分配2字节的大小的内存
string2 = 3; // 这样也是OK的, 为CxString预分配3字节的大小的内存
string3 = string1; // 这样也是OK的, 至少编译是没问题的, 但是如果析构函数里用free释放_pstr内存指针的时候可能会报错, 完整的代码必须重载运算符"=", 并在其中处理内存释放
如果在构造函数 CxString 前加入关键字 explicit ，新的构造函数为：
explicit CxString(int size)
{
_size = size;
// 代码同上, 省略...
}
那么会出现：
CxString string1(24); // 这样是OK的
CxString string2 = 10; // 这样是不行的, 因为explicit关键字取消了隐式转换
CxString string3; // 这样是不行的, 因为没有默认构造函数
CxString string4("aaaa"); // 这样是OK的
CxString string5 = "bbb"; // 这样也是OK的, 调用的是CxString(const char *p)
CxString string6 = 'c'; // 这样是不行的, 其实调用的是CxString(int size), 且size等于'c'的ascii码, 但explicit关键字取消了隐式转换
string1 = 2; // 这样也是不行的, 因为取消了隐式转换
string2 = 3; // 这样也是不行的, 因为取消了隐式转换
string3 = string1; // 这样也是不行的, 因为取消了隐式转换, 除非类实现操作符"="的重载
explicit关键字只对含有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是自动不会产生隐式转换的, 加与不加explicit关键字，此时的类构造函数都是显示的，有个特殊情况是：除了第一个参数以外的其他参数都有默认值的时候, explicit关键字依然有效，如果不加explicit关键字，将会是隐式。
规范化的C++程序，类构造函数前需要添加 explicit关键字。
