C/C++宏定义

最新推荐文章于 2022-05-13 17:53:06 发布
最新推荐文章于 2022-05-13 17:53:06 发布
阅读量450 收藏
点赞数
分类专栏： C/C++ 文章标签： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zz_hh_uu_/article/details/95364021
版权

基础知识

  1. 在一个宏中的参数前面使用一个#,预处理器会把这个参数转换为一个字符数组
  2. ##是一种分隔连接方式，它的作用是先分隔，然后进行强制连接
  • 宏中遇到#或##时就不会再展开宏中嵌套的宏了
  1. 宏定义中do{ }while(0)

  • 空的宏定义避免warning:

  • 存在一个独立的block，可以用来进行变量定义，进行比较复杂的实现。

  • 如果出现在判断语句过后的宏，这样可以保证作为一个整体来是实现

  • 在把宏引入代码中，会多出一个分号，从而会报错。这对这一点，可以将if和else语句用{}括起来，可以避免分号错误

#include <stdio.h>
#define MACRO_FUNC(cond) \
  do { \
    if (cond) \
      (void)0;\
    else \
      AssertFailure_(__func__, __FILE__, __LINE__, #cond);\
  } while (0)

void AssertFailure_(const char *func, const char *file, int line,const char *cond_str){
	printf("%s,%s,%d,%s\n",func,file,line,cond_str);
}
int main()
{
    if(2 > 1)
        MACRO_FUNC(0);
    else
        printf("Fail.\n");
    return 0;
}

main,macrot.cpp,17,0

#include <stdio.h>
void action1(){
    printf("======\n");
}

void action2(){
    printf("++++++\n");
}
#define foo(x) \
    action1(); \
    action2();

#define switch_(x,y) {int tmp; tmp=x;x=y;y=tmp;}

int main(){
    if(true)
        for (int i = 0; i < 2; ++i)
            foo();
    int x = 3;
    int y = 4;
    if(x>y){
        switch_(x,y);
    }
    else{
        printf("exp3\n");
    }
    
    return 0;
}

综合知识

例一：基本宏函数替换

#include<stdio.h> 
#include <cassert>
#include <iostream>
#include <string>
#define DEBUG_PRINT(msg)    do{printf("%s - %s - line:%d, file:%s", __DATE__, __TIME__, __LINE__, __FILE__);printf(msg);}while(0)
using std::string;

class LogMessage {
 public:
  LogMessage(const string &type) : fatal_(type == "FATAL") {
    std::cerr << type << ": ";
  }
  ~LogMessage() {
    std::cerr << std::endl;
    printf("12349999999");
    if(fatal_)
      exit(1);
  }
  std::ostream &stream() { return std::cerr; }

 private:
  bool fatal_;
};
#define CHECK(x) FstCheck(static_cast<bool>(x), #x, __FILE__, __LINE__)
#define LOG(type) LogMessage(#type).stream()


inline void FstCheck(bool x, const char* expr,
                const char *file, int line) {
  if (!x) {
    LOG(FATAL) << "Check failed: \"" << expr
               << "\" file: " << file
               << " line: " << line;
  }
}

#define TOW      (2) 
#define MUL(a,b) (a*b) 


int main() 
{ 
    CHECK(1);  
    printf("%d*%d=%d\n", TOW, TOW, MUL(TOW,TOW)); 
    printf("%d*%d=%d\n", (2), (2), ((2)*(2))); 
    return 0; 
}

例二：宏函数包装一层可以实现宏函数替换，并查看中间替换结果

#include<stdio.h> 
#include <cassert>
#include <iostream>
#include <string>

using std::string;


template <typename T>
class FlagRegister {
 public:
  static FlagRegister<T> *GetRegister() {
    static auto reg = new FlagRegister<T>;
    return reg;
  }
};

template <typename T>
struct FlagDescription {
  FlagDescription(T *addr, const char *doc, const char *type,
		  const char *file, const T val)
      : address(addr),
    doc_string(doc),
    type_name(type),
    file_name(file),
    default_value(val) {}

  T *address;
  const char *doc_string;
  const char *type_name;
  const char *file_name;
  const T default_value;
};

template <typename T>
class FlagRegisterer {
 public:
  FlagRegisterer(const string &name, const FlagDescription<T> &desc) {
    auto registr = FlagRegister<T>::GetRegister();
    registr->SetDescription(name, desc);
  }

 private:
  FlagRegisterer(const FlagRegisterer &) = delete;
  FlagRegisterer &operator=(const FlagRegisterer &) = delete;
};




#define DEFINE_VAR(type, name, value, doc)                                \
  type FLAGS_ ## name = value;                                            \
  static FlagRegisterer<type>                                             \
  name ## _flags_registerer(#name, FlagDescription<type>(&FLAGS_ ## name, \
                                                         doc,             \
                                                         #type,           \
                                                         __FILE__,        \
                                                         value))

#define DEFINE_bool(name, value, doc) DEFINE_VAR(bool, name, value, doc)

#define  _STR(x)  #x
#define  STR(x)  _STR(x)
int main() 
{ 
    printf(STR(DEFINE_VAR(bool,keep_isymbols, false, "Store input label symbol table with FST")));
    return 0; 
}

输出

bool FLAGS_keep_isymbols = false; static FlagRegisterer keep_isymbols_flags_registerer(“keep_isymbols”, FlagDescription(&FLAGS_keep_isymbols, “Store input label symbol table with FST”, “bool”, “tdefine.cc”, false))

例三：检查指针

#include <iostream>
using namespace std;

#define CHECK_NOTNULL(val) \
    CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val))

template <typename T>
T* CheckNotNull(const char* file, int line, const char *names, T* ptr)
{
    if (ptr == NULL)
    {
        cout << file << " " << line << ":" << names << endl;
    }
    return ptr;
}

int main(){
    int *p;
    *p = 5;
    CHECK_NOTNULL(p);
    int *q=CHECK_NOTNULL(p);
    q=NULL;
    CHECK_NOTNULL(q);
    return 0;
}

例四: 模版嵌入
Arctest.cpp

#include<iostream>
#include <string>
#include "generic-register.h"

namespace fst {
    template <class Arc>
    class Fst;
    struct FstReadOptions;
    template <class Arc>
    struct FstRegisterEntry {
        using Reader = Fst<Arc> *(*)(std::istream &istrm, const FstReadOptions &opts);
        using Converter = Fst<Arc> *(*)(const Fst<Arc> &fst);

        Reader reader;
        Converter converter;

        explicit FstRegisterEntry(Reader reader = nullptr,
                                  Converter converter = nullptr)
                : reader(reader), converter(converter) {}
    };

    template <class Arc>
    class FstRegister
            : public GenericRegister<string, FstRegisterEntry<Arc>, FstRegister<Arc>> {
    public:
        using Reader = typename FstRegisterEntry<Arc>::Reader;
        using Converter = typename FstRegisterEntry<Arc>::Converter;

        const Reader GetReader(const string &type) const {
            return this->GetEntry(type).reader;
        }

        const Converter GetConverter(const string &type) const {
            return this->GetEntry(type).converter;
        }

    protected:
        string ConvertKeyToSoFilename(const string &key) const override {
            string legal_type(key);
            return legal_type + "-fst.so";
        }
    };

    template <class FST>
    class FstRegisterer : public GenericRegisterer<FstRegister<typename FST::Arc>> {
    public:
        using Arc = typename FST::Arc;
        using Entry = typename FstRegister<Arc>::Entry;
        using Reader = typename FstRegister<Arc>::Reader;

        FstRegisterer()
                : GenericRegisterer<FstRegister<typename FST::Arc>>(FST().Type(),
                                                                    BuildEntry()) {}

    private:
        static Entry BuildEntry() {
            FST *(*reader)(std::istream & strm, const FstReadOptions &opts) =
            &FST::Read;
            return Entry(reinterpret_cast<Reader>(reader),
                         &FstRegisterer<FST>::Convert);
        }

        static Fst<Arc> *Convert(const Fst<Arc> &fst) { return new FST(fst); }
    };

#define REGISTER_FST(FST, Arc) \
  static fst::FstRegisterer<FST<Arc>> FST##_##Arc##_registerer

    template <class Arc>
    Fst<Arc> *Convert(const Fst<Arc> &fst, const string &fst_type) {
        auto *reg = FstRegister<Arc>::GetRegister();
        const auto converter = reg->GetConverter(fst_type);
        if (!converter) {
            cout << "Fst::Convert: Unknown FST type " << fst_type << " (arc type "
                       << Arc::Type() << ")";
            return nullptr;
        }
        return converter(fst);
    }

}

#define  _STR(x)  #x
#define  STR(x)  _STR(x)
int main()
{
    std::cout << STR(REGISTER_FST(A,B)) << std::endl;
    return 0;
}

register.h

#include <string>
namespace fst {

    template <class Arc>
    class Fst;

    struct FstReadOptions;
    template <class Arc>
    struct FstRegisterEntry {
        using Reader = Fst<Arc> *(*)(std::istream &istrm, const FstReadOptions &opts);
        using Converter = Fst<Arc> *(*)(const Fst<Arc> &fst);

        Reader reader;
        Converter converter;

        explicit FstRegisterEntry(Reader reader = nullptr,
                                  Converter converter = nullptr)
                : reader(reader), converter(converter) {}
    };

    template <class Arc>
    class FstRegister
            : public GenericRegister<string, FstRegisterEntry<Arc>, FstRegister<Arc>> {
    public:
        using Reader = typename FstRegisterEntry<Arc>::Reader;
        using Converter = typename FstRegisterEntry<Arc>::Converter;

        const Reader GetReader(const string &type) const {
            return this->GetEntry(type).reader;
        }

        const Converter GetConverter(const string &type) const {
            return this->GetEntry(type).converter;
        }

    protected:
        string ConvertKeyToSoFilename(const string &key) const override {
            string legal_type(key);
            ConvertToLegalCSymbol(&legal_type);
            return legal_type + "-fst.so";
        }
    };

    template <class FST>
    class FstRegisterer : public GenericRegisterer<FstRegister<typename FST::Arc>> {
    public:
        using Arc = typename FST::Arc;
        using Entry = typename FstRegister<Arc>::Entry;
        using Reader = typename FstRegister<Arc>::Reader;

        FstRegisterer()
                : GenericRegisterer<FstRegister<typename FST::Arc>>(FST().Type(),
                                                                    BuildEntry()) {}

    private:
        static Entry BuildEntry() {
            FST *(*reader)(std::istream & strm, const FstReadOptions &opts) =
            &FST::Read;
            return Entry(reinterpret_cast<Reader>(reader),
                         &FstRegisterer<FST>::Convert);
        }

        static Fst<Arc> *Convert(const Fst<Arc> &fst) { return new FST(fst); }
    };

#define REGISTER_FST(FST, Arc) \
  static fst::FstRegisterer<FST<Arc>> FST##_##Arc##_registerer

    template <class Arc>
    Fst<Arc> *Convert(const Fst<Arc> &fst, const string &fst_type) {
        auto *reg = FstRegister<Arc>::GetRegister();
        const auto converter = reg->GetConverter(fst_type);
        if (!converter) {
            FSTERROR() << "Fst::Convert: Unknown FST type " << fst_type << " (arc type "
                       << Arc::Type() << ")";
            return nullptr;
        }
        return converter(fst);
    }

}

generic-register.h

#include <string>
namespace fst {

    template <class Arc>
    class Fst;

    struct FstReadOptions;
    template <class Arc>
    struct FstRegisterEntry {
        using Reader = Fst<Arc> *(*)(std::istream &istrm, const FstReadOptions &opts);
        using Converter = Fst<Arc> *(*)(const Fst<Arc> &fst);

        Reader reader;
        Converter converter;

        explicit FstRegisterEntry(Reader reader = nullptr,
                                  Converter converter = nullptr)
                : reader(reader), converter(converter) {}
    };

    template <class Arc>
    class FstRegister
            : public GenericRegister<string, FstRegisterEntry<Arc>, FstRegister<Arc>> {
    public:
        using Reader = typename FstRegisterEntry<Arc>::Reader;
        using Converter = typename FstRegisterEntry<Arc>::Converter;

        const Reader GetReader(const string &type) const {
            return this->GetEntry(type).reader;
        }

        const Converter GetConverter(const string &type) const {
            return this->GetEntry(type).converter;
        }

    protected:
        string ConvertKeyToSoFilename(const string &key) const override {
            string legal_type(key);
            ConvertToLegalCSymbol(&legal_type);
            return legal_type + "-fst.so";
        }
    };

    template <class FST>
    class FstRegisterer : public GenericRegisterer<FstRegister<typename FST::Arc>> {
    public:
        using Arc = typename FST::Arc;
        using Entry = typename FstRegister<Arc>::Entry;
        using Reader = typename FstRegister<Arc>::Reader;

        FstRegisterer()
                : GenericRegisterer<FstRegister<typename FST::Arc>>(FST().Type(),
                                                                    BuildEntry()) {}

    private:
        static Entry BuildEntry() {
            FST *(*reader)(std::istream & strm, const FstReadOptions &opts) =
            &FST::Read;
            return Entry(reinterpret_cast<Reader>(reader),
                         &FstRegisterer<FST>::Convert);
        }

        static Fst<Arc> *Convert(const Fst<Arc> &fst) { return new FST(fst); }
    };

#define REGISTER_FST(FST, Arc) \
  static fst::FstRegisterer<FST<Arc>> FST##_##Arc##_registerer

    template <class Arc>
    Fst<Arc> *Convert(const Fst<Arc> &fst, const string &fst_type) {
        auto *reg = FstRegister<Arc>::GetRegister();
        const auto converter = reg->GetConverter(fst_type);
        if (!converter) {
            FSTERROR() << "Fst::Convert: Unknown FST type " << fst_type << " (arc type "
                       << Arc::Type() << ")";
            return nullptr;
        }
        return converter(fst);
    }

}

例五 函数指针

#include <iostream>
#include <map>

typedef int (*mathfunc)(int,int);
typedef std::map<std::string, mathfunc> BrepMap;
BrepMap g_brew_map;

#define RegisterMathFunc(func) \
namespace { \
    class __Register_##func{ \
        public: \
            __Register_##func() { g_brew_map[#func] = &func;}};\
    __Register_##func g_register_##func;}

int add(int a, int b){
    return a+b;
}
RegisterMathFunc(add)

int sub(int a, int b){
    return a-b;
}
RegisterMathFunc(sub)

int mul(int a, int b){
    return a*b;
}
RegisterMathFunc(mul)


int main()
{
    std::cout<< "number of register functions: " << g_brew_map.size() << std::endl;
    std::string math_method = "add";
    std::cout << "23 + 12  = " << g_brew_map[math_method](23,12) << std::endl;
    return 1;
}

number of register functions: 3
23 + 12 = 35

zoot
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++宏定义的可变参数详细解析
09-05
在C/C++编程中，宏定义是一种强大的工具，允许程序员在编译期间替换文本。在1999年的ISO C标准（通常称为C99）中引入了一项新特性，即宏可以拥有可变数量的参数，这极大地扩展了宏的使用范围。这种功能使得宏在某些...
openfst使用
chinabing的专栏
02-23 1万+
1. 安装 本人下载的是openfst-1.5.1版本 (1) ./configure (2) make (3) sudo make install 查看/usr/local/bin目录是否生成可执行文件，以及/usr/local/lib目录生成动态库文件libfst.so 2. C++程序 #include using namespace fst; int main()
CHECK_NOTNULL template
o1101574955的专栏
09-02 2248
#include using namespace std; #define CHECK_NOTNULL(val) \ CheckNotNull(__FILE__, __LINE__, "'" #val "' Must be non NULL", (val)) template T* CheckNotNull(const char* file, int line, const cha
c语言预处理宏的应用——_CRT_SECURE_NO_WARNINGS
weixin_44581918的博客
11-29 3147
在使用编译器编写c/c++的时候经常会用到一个问题： 这个问题可以通过在c文件头文件声明前加上一句宏定义来解决： #define _CRT_SECURE_NO_WARNINGS 但是为了体现编译器的功能，也可以通过在编译器的预处理宏定义处加入一个宏的说明——_CRT_SECURE_NO_WARNINGS，操作如下： 选择编辑手动输入上面的宏即可。 出现这个问题的原因是使用了老版本的c语言函数...
C++宏_CRT_SECURE_NO_WARNINGS错误
qq_33175506的博客
03-07 665
问题 错误信息提示 This function or variable may be unsafe. Consider using strcpy_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details. 解决方法 方法一 在头文件中加入宏 #include <iostream> using namespace std; #define _CRT_SECURE_NO_WA
C++宏定义函数
热门推荐
进击的码力的博客
04-13 1万+
在看OpenFoam源码的时候突然看到TypeName（“xxx”）；这句几乎每个类都有，一开始以为是TypeName（“xxx”）调用构造函数，细看不太对，应该是调用宏定义的函数，这个宏函数原型在$SRC/OpenFOAM/db/typeInfo文件里定义的。 如下： #define TypeName(TypeNameString) \ ClassName(TypeN...
C/C++语言宏定义使用实例详解
08-30
C/C++语言宏定义使用实例详解 C/C++语言宏定义是C/C++语言中一种非常重要的机制，它可以帮助开发者在编写代码时更加灵活和高效。宏定义可以用来防止头文件的重定义，实现跨平台的编译，简化代码编写等。 防止...
C/C++中宏定义的经典运用
08-10
在C/C++编程中，宏定义是一种强大的工具，尽管在C++中被模板和 inline 函数等特性逐渐取代，但宏定义在特定场景下依然有着不可忽视的作用。宏定义的本质是预处理器的一种特性，它会在编译之前对源代码进行文本替换，...
【C++】宏定义函数、内敛函数、static
张林克的博客
08-11 387
pass
Effective c++ 条款2中宏定义函数出错细究
yizhangbiao的专栏
06-26 276
以前在比赛中经常利用宏定义函数，结果有时候就会出现非常奇怪的错误，例如：#include&lt;iostream&gt; #include&lt;stdio.h&gt; using namespace std; int f(int a) { return a; } #define max(a,b) f((a)&gt;(b)?(a):(b)) /* int max(int a,int b) { ...
stl queue 用法
nyist_yangguang的博客
11-25 409
stl queue 用法 调用的时候要有头文件： #include 或 #include + #include #include 详细用法: 定义一个queue的变量 queue M 查看是否为空范例 M.empty() 是的话返回1，不是返回0; 从已有元素后面增加元素 M.push() 输出现有元素的个数 M.s
C++谷歌开源项目glog学习笔记
小鱼酱的博客
01-02 565
下载地址 https://github.com/google/glog qt creater +cmake 安装qt creater ,勾选minggw vs2019 +cmake 安装vs2019 勾选cmake ，c++开发相关 勾选共享库
google guava工具包 checkNotNull的作用
Fairy_Z的博客
09-28 1万+
checkNotNull 源码如下： Preconditions.checkNotNull(object); public static T> T checkNotNull(T reference) { if (reference == null) { throw new NullPointerException(); } return reference; } 使用
OpenFst的创建和读取
Richardfan的博客
11-22 3772
kaldi openFST
C/C++宏的使用总结
yy13210520的专栏
12-25 2120
C/C++宏的使用总结     宏替换是C/C++系列语言的技术特色，C/C++语言提供了强大的宏替换功能，源代码在进入编译器之前，要先经过一个称为“预处理器”的模块，这个模块将宏根据编译参数和实际编码进行展开，展开后的代码才正式进入编译器，进行词法分析、语法分析等等。     我们常用的宏替换主要有这么几个类型。 1.宏常量     在ACM等算法竞赛中，经常会把数组的最大下标通
c/c++中的NULL，nullptr，0
duchenlong的博客
06-06 761
关于c/c++，中的NULL，nullptr，0之间的关系，以及底层的程序部分。 了解宏定义的关键字和隐式类型转换
C++单例类宏定义，方便快速实现单例类
luoyayun361的专栏
05-13 1687
前言 之前已经写过两篇博客关于单例类的写法： Qt C++单例类写法 C++设计模式–单例模式(Singleton)及单例通用模板 今天再加个菜，通过宏定义，用更简单的方式来实现单例类。使用非常方便。 正文 话不多说，直接上代码，定义一个头文件，singleton.h #pragma once /* * @brief :定义单例类宏 */ #include <mutex> #define DISABLE_COPY(Class) \ Class(const Class&am
c++用宏定义来编写函数#define
RToax
12-14 3728
#include&lt;iostream&gt; #include&lt;stdlib.h&gt; #include&lt;assert.h&gt; #include"hello.h" #ifdef _OPENMP #include&lt;omp.h&gt; #endif #define CHECK(arg){ \ ...
C语言宏定义和宏定义函数
10-04 4218
C语言宏定义和宏定义函数 　要写好C语言，漂亮的宏定义是非常重要的。宏定义可以帮助我们防止出错，提高代码的可移植性和可读性等。 　　在软件开发过程中，经常有一些常用或者通用的功能或者代码段，这些功能既可以写成函数，也可以封装成为宏定义。那么究竟是用函数好，还是宏定义好？这就要求我们对二者进行合理的取舍。 　　我们来看一个例子，比较两个数或者表达式大小，首先我们把它写成宏定义：
CC++头文件一览.doc
08-09
在C/C++编程中，头文件是包含函数声明、宏定义和其他编译时所需信息的文件。以下是对部分关键头文件和相关函数的详细说明： 1. `<assert.h>`：提供了断言宏`assert(expression)`，用于在调试阶段检查程序的逻辑是否...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值