gflags中宏定义和模板高手用法

最新推荐文章于 2024-06-05 09:58:40 发布
最新推荐文章于 2024-06-05 09:58:40 发布
阅读量322 收藏
点赞数
分类专栏： c++库学习 文章标签： templates 泛型 c++ 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37702639/article/details/118771653
版权

预备知识

宏定义__STDC_FORMAT_MACROS

  • 64位整数，在32位系统中是long long int，在64位系统中是long int
  • 64位整数printf打印，在32位系统中是lld，在64位系统中是ld
  • 跨平台打印方案，printf("%" PRId64 "\n", value) \\long int value(64位) long long int value(32位)，PRId64在inttypes.h中定义
  • 这个设计是给c用的，c++定义一个__STDC_FORMAT_MACROS宏显示打开它

宏定义__attribute__((visibility("default")))

https://blog.csdn.net/mutourenzhang/article/details/47803803

  • 用于控制链接库总函数对外是否可见
  • windows下#define GFLAGS_DLL_DECLARE_FLAG __declspec(dllimport)

预处理结果查看

  • gcc -E只预处理不编译

利用宏和模板存储值类型

  • 假设类value_buffer_字段可以存储值；type_字段存储值对应bool，int，string等类型，如何实现
  • 自己经常用的实现方式(构造时显示传入值类型，只有一个构造函数)
#include <iostream>
#include <string>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdint.h>
#include <inttypes.h>

using std::cout;
using std::string;

typedef signed char int8;
typedef unsigned char uint8;
typedef int32_t int32;
typedef uint32_t uint32;
typedef int64_t int64;
typedef uint64_t uint64;
typedef std::string clstring;

enum ValueType {
  FV_BOOL = 0,
  FV_INT32 = 1,
  FV_UINT32 = 2,
  FV_INT64 = 3,
  FV_UINT64 = 4,
  FV_DOUBLE = 5,
  FV_STRING = 6,
  FV_MAX_INDEX = 6,
};

#define strto64 strtoll
#define strtou64 strtoull

#define VALUE_AS(type) *reinterpret_cast<type *>(value_buffer_)
#define OTHER_VALUE_AS(fv, type) *reinterpret_cast<type *>(fv.value_buffer_)
#define SET_VALUE_AS(type, value) VALUE_AS(type) = (value)

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

class FlagValue {
public:
  FlagValue(void *const valbuf, int8 type, bool transfer_ownership_of_value)
      : value_buffer_(valbuf), type_(type),
        owns_value_(transfer_ownership_of_value) {}
  ~FlagValue() {
    if (!owns_value_) {
      return;
    }
    switch (type_) {
    case FV_BOOL:
      delete reinterpret_cast<bool *>(value_buffer_);
      break;
    case FV_INT32:
      delete reinterpret_cast<int32 *>(value_buffer_);
      break;
    case FV_UINT32:
      delete reinterpret_cast<uint32 *>(value_buffer_);
      break;
    case FV_INT64:
      delete reinterpret_cast<int64 *>(value_buffer_);
      break;
    case FV_UINT64:
      delete reinterpret_cast<uint64 *>(value_buffer_);
      break;
    case FV_DOUBLE:
      delete reinterpret_cast<double *>(value_buffer_);
      break;
    case FV_STRING:
      delete reinterpret_cast<string *>(value_buffer_);
      break;
    }
  }

  bool ParseFrom(const char *value) {
    if (type_ == FV_BOOL) {
      const char *kTrue[] = {"1", "t", "true", "y", "yes"};
      const char *kFalse[] = {"0", "f", "false", "n", "no"};
      for (size_t i = 0; i < sizeof(kTrue) / sizeof(*kTrue); ++i) {
        if (strcasecmp(value, kTrue[i]) == 0) {
          SET_VALUE_AS(bool, true);
          return true;
        } else if (strcasecmp(value, kFalse[i]) == 0) {
          SET_VALUE_AS(bool, false);
          return true;
        }
      }
      return false; // didn't match a legal input

    } else if (type_ == FV_STRING) {
      SET_VALUE_AS(string, value);
      return true;
    }

    // OK, it's likely to be numeric, and we'll be using a strtoXXX method.
    if (value[0] == '\0') // empty-string is only allowed for string type.
      return false;
    char *end;
    // Leading 0x puts us in base 16.  But leading 0 does not put us in base 8!
    // It caused too many bugs when we had that behavior.
    int base = 10; // by default
    if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X'))
      base = 16;
    errno = 0;

    switch (type_) {
    case FV_INT32: {
      const int64 r = strto64(value, &end, base);
      if (errno || end != value + strlen(value))
        return false;                 // bad parse
      if (static_cast<int32>(r) != r) // worked, but number out of range
        return false;
      SET_VALUE_AS(int32, static_cast<int32>(r));
      return true;
    }
    case FV_UINT32: {
      while (*value == ' ')
        value++;
      if (*value == '-')
        return false; // negative number
      const uint64 r = strtou64(value, &end, base);
      if (errno || end != value + strlen(value))
        return false;                  // bad parse
      if (static_cast<uint32>(r) != r) // worked, but number out of range
        return false;
      SET_VALUE_AS(uint32, static_cast<uint32>(r));
      return true;
    }
    case FV_INT64: {
      const int64 r = strto64(value, &end, base);
      if (errno || end != value + strlen(value))
        return false; // bad parse
      SET_VALUE_AS(int64, r);
      return true;
    }
    case FV_UINT64: {
      while (*value == ' ')
        value++;
      if (*value == '-')
        return false; // negative number
      const uint64 r = strtou64(value, &end, base);
      if (errno || end != value + strlen(value))
        return false; // bad parse
      SET_VALUE_AS(uint64, r);
      return true;
    }
    case FV_DOUBLE: {
      const double r = strtod(value, &end);
      if (errno || end != value + strlen(value))
        return false; // bad parse
      SET_VALUE_AS(double, r);
      return true;
    }
    default: {
      assert(false); // unknown type
      return false;
    }
    }
  }

  string ToString() const {
    char intbuf[64]; // enough to hold even the biggest number
    switch (type_) {
    case FV_BOOL:
      return VALUE_AS(bool) ? "true" : "false";
    case FV_INT32:
      snprintf(intbuf, sizeof(intbuf), "%" PRId32, VALUE_AS(int32));
      return intbuf;
    case FV_UINT32:
      snprintf(intbuf, sizeof(intbuf), "%" PRIu32, VALUE_AS(uint32));
      return intbuf;
    case FV_INT64:
      snprintf(intbuf, sizeof(intbuf), "%" PRId64, VALUE_AS(int64));
      return intbuf;
    case FV_UINT64:
      snprintf(intbuf, sizeof(intbuf), "%" PRIu64, VALUE_AS(uint64));
      return intbuf;
    case FV_DOUBLE:
      snprintf(intbuf, sizeof(intbuf), "%.17g", VALUE_AS(double));
      return intbuf;
    case FV_STRING:
      return VALUE_AS(string);
    default:
      assert(false);
      return ""; // unknown type
    }
  }

  ValueType Type() const { return static_cast<ValueType>(type_); }

private:
  void *const value_buffer_; // points to the buffer holding our data
  const int8 type_;          // how to interpret value_
  const bool owns_value_;    // whether to free value on destruct
};

int main(int argc, char **argv) {
  int val1 = 30;
  FlagValue value1(&val1, FV_INT32, false);
  std::cout << value1.ToString() << std::endl;

  string val2 = "test!!!";
  FlagValue value2(&val2, FV_STRING, false);
  std::cout << value2.ToString() << std::endl;
    
  return 0;
}
  • 看Google的gflags源码种利用构造函数模板实现
#include <iostream>
#include <string>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdint.h>
#include <inttypes.h>

using std::cout;
using std::string;

typedef signed char int8;
typedef unsigned char uint8;
typedef int32_t int32;
typedef uint32_t uint32;
typedef int64_t int64;
typedef uint64_t uint64;
typedef std::string clstring;

enum ValueType {
  FV_BOOL = 0,
  FV_INT32 = 1,
  FV_UINT32 = 2,
  FV_INT64 = 3,
  FV_UINT64 = 4,
  FV_DOUBLE = 5,
  FV_STRING = 6,
  FV_MAX_INDEX = 6,
};

#define strto64 strtoll
#define strtou64 strtoull

#define VALUE_AS(type) *reinterpret_cast<type *>(value_buffer_)
#define OTHER_VALUE_AS(fv, type) *reinterpret_cast<type *>(fv.value_buffer_)
#define SET_VALUE_AS(type, value) VALUE_AS(type) = (value)

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

template <typename FlagType> struct FlagValueTraits;

// Map the given C++ type to a value of the ValueType enum at compile time.
#define DEFINE_FLAG_TRAITS(type, value)                                        \
  template <> struct FlagValueTraits<type> {                                   \
    static const ValueType kValueType = value;                                 \
  }

DEFINE_FLAG_TRAITS(bool, ValueType::FV_BOOL);
DEFINE_FLAG_TRAITS(int32, ValueType::FV_INT32);
DEFINE_FLAG_TRAITS(uint32, ValueType::FV_UINT32);
DEFINE_FLAG_TRAITS(int64, ValueType::FV_INT64);
DEFINE_FLAG_TRAITS(uint64, ValueType::FV_UINT64);
DEFINE_FLAG_TRAITS(double, ValueType::FV_DOUBLE);
DEFINE_FLAG_TRAITS(std::string, ValueType::FV_STRING);

#undef DEFINE_FLAG_TRAITS

class FlagValue {
public:
  template <typename FlagType>
  FlagValue(FlagType *valbuf, bool transfer_ownership_of_value)
      : value_buffer_(valbuf), type_(FlagValueTraits<FlagType>::kValueType),
        owns_value_(transfer_ownership_of_value) {}

  ~FlagValue() {
    if (!owns_value_) {
      return;
    }
    switch (type_) {
    case FV_BOOL:
      delete reinterpret_cast<bool *>(value_buffer_);
      break;
    case FV_INT32:
      delete reinterpret_cast<int32 *>(value_buffer_);
      break;
    case FV_UINT32:
      delete reinterpret_cast<uint32 *>(value_buffer_);
      break;
    case FV_INT64:
      delete reinterpret_cast<int64 *>(value_buffer_);
      break;
    case FV_UINT64:
      delete reinterpret_cast<uint64 *>(value_buffer_);
      break;
    case FV_DOUBLE:
      delete reinterpret_cast<double *>(value_buffer_);
      break;
    case FV_STRING:
      delete reinterpret_cast<string *>(value_buffer_);
      break;
    }
  }

  bool ParseFrom(const char *value) {
    if (type_ == FV_BOOL) {
      const char *kTrue[] = {"1", "t", "true", "y", "yes"};
      const char *kFalse[] = {"0", "f", "false", "n", "no"};
      for (size_t i = 0; i < sizeof(kTrue) / sizeof(*kTrue); ++i) {
        if (strcasecmp(value, kTrue[i]) == 0) {
          SET_VALUE_AS(bool, true);
          return true;
        } else if (strcasecmp(value, kFalse[i]) == 0) {
          SET_VALUE_AS(bool, false);
          return true;
        }
      }
      return false; // didn't match a legal input

    } else if (type_ == FV_STRING) {
      SET_VALUE_AS(string, value);
      return true;
    }

    // OK, it's likely to be numeric, and we'll be using a strtoXXX method.
    if (value[0] == '\0') // empty-string is only allowed for string type.
      return false;
    char *end;
    // Leading 0x puts us in base 16.  But leading 0 does not put us in base 8!
    // It caused too many bugs when we had that behavior.
    int base = 10; // by default
    if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X'))
      base = 16;
    errno = 0;

    switch (type_) {
    case FV_INT32: {
      const int64 r = strto64(value, &end, base);
      if (errno || end != value + strlen(value))
        return false;                 // bad parse
      if (static_cast<int32>(r) != r) // worked, but number out of range
        return false;
      SET_VALUE_AS(int32, static_cast<int32>(r));
      return true;
    }
    case FV_UINT32: {
      while (*value == ' ')
        value++;
      if (*value == '-')
        return false; // negative number
      const uint64 r = strtou64(value, &end, base);
      if (errno || end != value + strlen(value))
        return false;                  // bad parse
      if (static_cast<uint32>(r) != r) // worked, but number out of range
        return false;
      SET_VALUE_AS(uint32, static_cast<uint32>(r));
      return true;
    }
    case FV_INT64: {
      const int64 r = strto64(value, &end, base);
      if (errno || end != value + strlen(value))
        return false; // bad parse
      SET_VALUE_AS(int64, r);
      return true;
    }
    case FV_UINT64: {
      while (*value == ' ')
        value++;
      if (*value == '-')
        return false; // negative number
      const uint64 r = strtou64(value, &end, base);
      if (errno || end != value + strlen(value))
        return false; // bad parse
      SET_VALUE_AS(uint64, r);
      return true;
    }
    case FV_DOUBLE: {
      const double r = strtod(value, &end);
      if (errno || end != value + strlen(value))
        return false; // bad parse
      SET_VALUE_AS(double, r);
      return true;
    }
    default: {
      assert(false); // unknown type
      return false;
    }
    }
  }

  string ToString() const {
    char intbuf[64]; // enough to hold even the biggest number
    switch (type_) {
    case FV_BOOL:
      return VALUE_AS(bool) ? "true" : "false";
    case FV_INT32:
      snprintf(intbuf, sizeof(intbuf), "%" PRId32, VALUE_AS(int32));
      return intbuf;
    case FV_UINT32:
      snprintf(intbuf, sizeof(intbuf), "%" PRIu32, VALUE_AS(uint32));
      return intbuf;
    case FV_INT64:
      snprintf(intbuf, sizeof(intbuf), "%" PRId64, VALUE_AS(int64));
      return intbuf;
    case FV_UINT64:
      snprintf(intbuf, sizeof(intbuf), "%" PRIu64, VALUE_AS(uint64));
      return intbuf;
    case FV_DOUBLE:
      snprintf(intbuf, sizeof(intbuf), "%.17g", VALUE_AS(double));
      return intbuf;
    case FV_STRING:
      return VALUE_AS(string);
    default:
      assert(false);
      return ""; // unknown type
    }
  }

  ValueType Type() const { return static_cast<ValueType>(type_); }

private:
  void *const value_buffer_; // points to the buffer holding our data
  const int8 type_;          // how to interpret value_
  const bool owns_value_;    // whether to free value on destruct
};

int main(int argc, char **argv) {
  int val1 = 30;
  FlagValue value1(&val1, false);
  std::cout << value1.ToString() << std::endl;

  string val2 = "test!!!";
  FlagValue value2(&val2, false);
  std::cout << value2.ToString() << std::endl;

  return 0;
}
  • 构造了不同类型的模板构造函数(看编译器对模板的实现，是不是多个构造函数重载，不误导读者)，且构造函数参数根据类型传入不同类型FlagValueTraits结构体，根据结构体kValueType值映射类型，和前一种实现显示传入类型并无本质区别
  • Google这种实现好处是什么？
  • 为了更好理解代码，只预编译源代码如下
//g++ main.cc -E -g -o main
//已经去掉了标准库的预处理替换(2万多行)
......

using std::cout;
using std::string;

typedef signed char int8;
typedef unsigned char uint8;
typedef int32_t int32;
typedef uint32_t uint32;
typedef int64_t int64;
typedef uint64_t uint64;
typedef std::string clstring;

enum ValueType {
  FV_BOOL = 0,
  FV_INT32 = 1,
  FV_UINT32 = 2,
  FV_INT64 = 3,
  FV_UINT64 = 4,
  FV_DOUBLE = 5,
  FV_STRING = 6,
  FV_MAX_INDEX = 6,
};

template <typename FlagType> struct FlagValueTraits;

template <> struct FlagValueTraits<bool> {
  static const ValueType kValueType = ValueType::FV_BOOL;
};
template <> struct FlagValueTraits<int32> {
  static const ValueType kValueType = ValueType::FV_INT32;
};
template <> struct FlagValueTraits<uint32> {
  static const ValueType kValueType = ValueType::FV_UINT32;
};
template <> struct FlagValueTraits<int64> {
  static const ValueType kValueType = ValueType::FV_INT64;
};
template <> struct FlagValueTraits<uint64> {
  static const ValueType kValueType = ValueType::FV_UINT64;
};
template <> struct FlagValueTraits<double> {
  static const ValueType kValueType = ValueType::FV_DOUBLE;
};
template <> struct FlagValueTraits<std::string> {
  static const ValueType kValueType = ValueType::FV_STRING;
};

class FlagValue {
public:
  template <typename FlagType>
  FlagValue(FlagType *valbuf, bool transfer_ownership_of_value)
      : value_buffer_(valbuf), type_(FlagValueTraits<FlagType>::kValueType),
        owns_value_(transfer_ownership_of_value) {}

  ~FlagValue() {
    if (!owns_value_) {
      return;
    }
    switch (type_) {
    case FV_BOOL:
      delete reinterpret_cast<bool *>(value_buffer_);
      break;
    case FV_INT32:
      delete reinterpret_cast<int32 *>(value_buffer_);
      break;
    case FV_UINT32:
      delete reinterpret_cast<uint32 *>(value_buffer_);
      break;
    case FV_INT64:
      delete reinterpret_cast<int64 *>(value_buffer_);
      break;
    case FV_UINT64:
      delete reinterpret_cast<uint64 *>(value_buffer_);
      break;
    case FV_DOUBLE:
      delete reinterpret_cast<double *>(value_buffer_);
      break;
    case FV_STRING:
      delete reinterpret_cast<string *>(value_buffer_);
      break;
    }
  }

  bool ParseFrom(const char *value) {
    if (type_ == FV_BOOL) {
      const char *kTrue[] = {"1", "t", "true", "y", "yes"};
      const char *kFalse[] = {"0", "f", "false", "n", "no"};
      for (size_t i = 0; i < sizeof(kTrue) / sizeof(*kTrue); ++i) {
        if (strcasecmp(value, kTrue[i]) == 0) {
          *reinterpret_cast<bool *>(value_buffer_) = (true);
          return true;
        } else if (strcasecmp(value, kFalse[i]) == 0) {
          *reinterpret_cast<bool *>(value_buffer_) = (false);
          return true;
        }
      }
      return false;

    } else if (type_ == FV_STRING) {
      *reinterpret_cast<string *>(value_buffer_) = (value);
      return true;
    }

    if (value[0] == '\0')
      return false;
    char *end;

    int base = 10;
    if (value[0] == '0' && (value[1] == 'x' || value[1] == 'X'))
      base = 16;

# 125 "/home/niu/cplusstudy/aa.cc" 3 4
    (*__errno_location())
# 125 "/home/niu/cplusstudy/aa.cc"
        = 0;

    switch (type_) {
    case FV_INT32: {
      const int64 r = strtoll(value, &end, base);
      if (
# 130 "/home/niu/cplusstudy/aa.cc" 3 4
          (*__errno_location())
# 130 "/home/niu/cplusstudy/aa.cc"
          || end != value + strlen(value))
        return false;
      if (static_cast<int32>(r) != r)
        return false;
      *reinterpret_cast<int32 *>(value_buffer_) = (static_cast<int32>(r));
      return true;
    }
    case FV_UINT32: {
      while (*value == ' ')
        value++;
      if (*value == '-')
        return false;
      const uint64 r = strtoull(value, &end, base);
      if (
# 143 "/home/niu/cplusstudy/aa.cc" 3 4
          (*__errno_location())
# 143 "/home/niu/cplusstudy/aa.cc"
          || end != value + strlen(value))
        return false;
      if (static_cast<uint32>(r) != r)
        return false;
      *reinterpret_cast<uint32 *>(value_buffer_) = (static_cast<uint32>(r));
      return true;
    }
    case FV_INT64: {
      const int64 r = strtoll(value, &end, base);
      if (
# 152 "/home/niu/cplusstudy/aa.cc" 3 4
          (*__errno_location())
# 152 "/home/niu/cplusstudy/aa.cc"
          || end != value + strlen(value))
        return false;
      *reinterpret_cast<int64 *>(value_buffer_) = (r);
      return true;
    }
    case FV_UINT64: {
      while (*value == ' ')
        value++;
      if (*value == '-')
        return false;
      const uint64 r = strtoull(value, &end, base);
      if (
# 163 "/home/niu/cplusstudy/aa.cc" 3 4
          (*__errno_location())
# 163 "/home/niu/cplusstudy/aa.cc"
          || end != value + strlen(value))
        return false;
      *reinterpret_cast<uint64 *>(value_buffer_) = (r);
      return true;
    }
    case FV_DOUBLE: {
      const double r = strtod(value, &end);
      if (
# 170 "/home/niu/cplusstudy/aa.cc" 3 4
          (*__errno_location())
# 170 "/home/niu/cplusstudy/aa.cc"
          || end != value + strlen(value))
        return false;
      *reinterpret_cast<double *>(value_buffer_) = (r);
      return true;
    }
    default: {

# 176 "/home/niu/cplusstudy/aa.cc" 3 4
      ((
# 176 "/home/niu/cplusstudy/aa.cc"
           false
# 176 "/home/niu/cplusstudy/aa.cc" 3 4
           )
           ? static_cast<void>(0)
           : __assert_fail(
# 176 "/home/niu/cplusstudy/aa.cc"
                 "false"
# 176 "/home/niu/cplusstudy/aa.cc" 3 4
                 ,
                 "/home/niu/cplusstudy/aa.cc", 176, __PRETTY_FUNCTION__))
# 176 "/home/niu/cplusstudy/aa.cc"
          ;
      return false;
    }
    }
  }

  string ToString() const {
    char intbuf[64];
    switch (type_) {
    case FV_BOOL:
      return *reinterpret_cast<bool *>(value_buffer_) ? "true" : "false";
    case FV_INT32:
      snprintf(intbuf, sizeof(intbuf),
               "%"
# 188 "/home/niu/cplusstudy/aa.cc" 3 4
               "d"
# 188 "/home/niu/cplusstudy/aa.cc"
               ,
               *reinterpret_cast<int32 *>(value_buffer_));
      return intbuf;
    case FV_UINT32:
      snprintf(intbuf, sizeof(intbuf),
               "%"
# 191 "/home/niu/cplusstudy/aa.cc" 3 4
               "u"
# 191 "/home/niu/cplusstudy/aa.cc"
               ,
               *reinterpret_cast<uint32 *>(value_buffer_));
      return intbuf;
    case FV_INT64:
      snprintf(intbuf, sizeof(intbuf),
               "%"
# 194 "/home/niu/cplusstudy/aa.cc" 3 4
               "l"
               "d"
# 194 "/home/niu/cplusstudy/aa.cc"
               ,
               *reinterpret_cast<int64 *>(value_buffer_));
      return intbuf;
    case FV_UINT64:
      snprintf(intbuf, sizeof(intbuf),
               "%"
# 197 "/home/niu/cplusstudy/aa.cc" 3 4
               "l"
               "u"
# 197 "/home/niu/cplusstudy/aa.cc"
               ,
               *reinterpret_cast<uint64 *>(value_buffer_));
      return intbuf;
    case FV_DOUBLE:
      snprintf(intbuf, sizeof(intbuf), "%.17g",
               *reinterpret_cast<double *>(value_buffer_));
      return intbuf;
    case FV_STRING:
      return *reinterpret_cast<string *>(value_buffer_);
    default:

# 205 "/home/niu/cplusstudy/aa.cc" 3 4
      ((
# 205 "/home/niu/cplusstudy/aa.cc"
           false
# 205 "/home/niu/cplusstudy/aa.cc" 3 4
           )
           ? static_cast<void>(0)
           : __assert_fail(
# 205 "/home/niu/cplusstudy/aa.cc"
                 "false"
# 205 "/home/niu/cplusstudy/aa.cc" 3 4
                 ,
                 "/home/niu/cplusstudy/aa.cc", 205, __PRETTY_FUNCTION__))
# 205 "/home/niu/cplusstudy/aa.cc"
          ;
      return "";
    }
  }

  ValueType Type() const { return static_cast<ValueType>(type_); }

private:
  void *const value_buffer_;
  const int8 type_;
  const bool owns_value_;
};

int main(int argc, char **argv) {
  int val1 = 30;
  FlagValue value1(&val1, false);
  std::cout << value1.ToString() << std::endl;

  string val2 = "test!!!";
  FlagValue value2(&val2, false);
  std::cout << value2.ToString() << std::endl;

  return 0;
}
NxxCalm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
函数模板与宏定义
04-16
函数模板与宏定义。代码复用的不同方式的定义，包含了用函数模板实现代码复用，用宏定义展开为函数的定义与使用。
宏定义 和 函数模板
weixin_34280237的博客
11-29 520
#include<iostream> using namespace std; #define max(a,b) (((a)>(b)? (a):(b))) int main() { int a=10; int b=0; int c=max(++a,++b); cout<<"a:"<<a<<" b:"<<b&l...
google全家桶：glog/gflags/gtest编译安装和使用
最新发布
qq_29022265的博客
06-05 957
gflags：Google开源命令行参数解析工具，从环境变量或配置文件中读配置glog：Google开源日志库，用来打印日志，支持多种级别日志打印gtest：Google开源的C++测试框架，可在源代码中定义测试用例Google的开源代码，有保证多人使用和验证过经典的日志库。
Google gflags使用说明
热门推荐
lezardfu的专栏
04-15 6万+
gflags是什么： gflags是google的一个开源的处理命令行参数的库，使用c++开发，具备python接口，可以替代getopt。 gflags使用起来比getopt方便，但是不支持参数的简写（例如getopt支持--list缩写成-l，gflags不支持）。 如何安装使用gflags： 安装：请访问地址https://code.google.com/p/gflags/，下载
Gflags简单使用
Done_for_me的博客
04-17 455
gflags的简单使用，真的超坤简单！
类模板和宏定义应用
tangyanzhi1111的专栏
04-27 857
#include "stdafx.h" #define THREAD_LOCAL(class_name, ident_name) \ CThreadLocal ident_name; struct CMyThreadData { int mSomeData; }; class CThreadLocalObject { public : int m_nSlot;
安装glog和gflags
06-19
安装glog和gflags
glog和gflags
05-14
2. **使用方法**：glog库通常通过预处理器宏`#include <glog/logging.h>`引入。初始化日志系统通常在程序入口点调用`google::InitGoogleLogging("your_program_name")`，然后可以使用`LOG(INFO) 这样的语法进行日志...
gflags-master.rar
07-31
1. **参数定义**：`gflags` 允许开发者在代码中声明命令行参数，每个参数都有自己的名称、默认值和描述。例如，可以定义一个名为 `-log_level` 的参数来控制日志级别。 2. **参数解析**：当程序启动时，`gflags` 会...
GFLAGS使用手册
08-04
这个例子演示了 GFLAGS 的基本使用方法。包括声明标志位、定义标志位、访问标志位等内容。 2.2 初始化 GFLAGS 在使用 GFLAGS 之前，需要初始化 GFLAGS。初始化 GFLAGS 需要包含 gflags 头文件，并调用 GFLAGS 的...
gflags_gflags_
09-30
在C++程序中使用`gflags`，首先需要包含对应的头文件，然后定义你需要的命令行参数。例如，定义一个名为`--input_file`的字符串参数： ```cpp #include <gflags/gflags.h> DEFINE_string(input_file, "", "指定...
关于gflags的使用学习笔记
weijie1984222的博客
04-28 168
一、介绍 gflags是google的一个开源的处理命令行参数的库，使用c++开发。 ubuntu下使用命令安装： sudo apt-get install libgflags* 二、关键点 1、DEFINE宏有三个参数：标志的名称、默认值以及描述其用法的字符串。 2、定义的flag可以像正常的变量一样使用，只需在前面加上 FLAGS_前缀。 3、可以在任何源文件中定义flag，但是每个只能定义一...
GCC：-D__STDC_FORMAT_MACROS
what, when, why, how...
12-15 1076
int64_t用来表示64位整数，在32位系统中是long long int，在64位系统中是long int， 所以打印int64_t的格式化方法是： printf("%ld", value); // 64bit OS printf("%lld", value); // 32bit OS 当然有跨平台的方法： #include <inttypes.h> printf("%" PRId64 "\n", value); /usr/include/inttypes.h：原.
google gflags的参数解析，便捷实用
天行健，地势坤
06-28 619
命令行参数解析，一直是我们后段开发人员需要经常使用的一个功能，用来从终端解析接口的输入 ，并做出对应的处理。这里为使用C++/python的开发人员推荐一个便捷的命令行解析接口集 gflags。 我们之前使用C的getopt/getopt_long 函数需要自己使用其接口并编写大量的周边代码达到解析参数的目的，如果转到C++还使用上面的函数，代码会过于冗余。那么gflags就很好的解决了这个问题，我们不需要再数着冒号 "a????️cd:"添加参数了，不需要为每个传入的参数做类型转化。 接下来的gflags
命令行解析工具gflags详解(main函数参数/参数文件解析)
惊鸿一博
05-30 2203
目录 一、Gflags简介 二、下载和安装 三、用CMake声明flags之间的依赖关系 四、定义flag 五、flag变量 六、在其他文件中调用flag变量 七、完整性检查——RegisterFlagValidator 八、flag与参数 九、命令行设置flag 十、更改flag默认值 一、Gflags简介 Gflags是一种命令行解析工具，主要用于解析用命令行执行可执行文件时传入的参数。与getops()不同的是，在gflags中flag可以分散的定义在各个文件之中，而不用定
【C++】gflags的使用
mjiansun的专栏
11-15 2万+
google开源的gflags是一套命令行参数解析工具，比getopt功能更强大，使用起来更加方便，gflags还支持从环境变量、配置文件读取参数（可用gflags代替配置文件）。本文简单介绍gflags的使用，内容主要译自 http://gflags.googlecode.com/svn/trunk/doc/gflags.html 。   定义参数  使用flags需要包含头文件  #...
windows下在QT里调用ffmpeg库处理音频视频数据时，出现error missing -D__STDC_FORMAT_MACROS 错误的解决方法(MINGW32编译器)。
04-06 1003
当前QT版本：5.12 编译器：MinGW 32位 QT的xxx.pro工程文件： QT += core gui QT += multimediawidgets QT += xml QT += multimedia QT += network QT += widgets QT += serialport g...
#define总结-#define用法集锦 （网上资料汇集）
jernymy的专栏
11-13 7431
 Definition：The #define Directive　　You can use the #define directive to give a meaningful name to a constant in your program. The two forms of the syntax are: 　　Syntax　　#define identifier to
argparse和gflags
09-05
argparse和gflags是两种常用的命令行参数解析库。 argparse是Python标准库中的一个模块，用于解析命令行参数。通过argparse，我们可以定义我们的脚本可以接受的参数的类型、数量以及相应的默认值等信息。argparse还...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值