利用“宏元编程”解决重复问题

最新推荐文章于 2023-03-07 10:07:59 发布
最新推荐文章于 2023-03-07 10:07:59 发布
阅读量512 收藏
点赞数
分类专栏： 设计 C++ 文章标签： 编程 struct python file import object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/godsme_yuan/article/details/6593695
版权
本文介绍了如何通过宏元编程技术解决配置数据在不同结构中重复的问题。通过定义元数据并创建一系列宏，实现了配置信息的自动生成功能，简化了StudentConfig和StudentOptionalConfig结构的定义，并给出了一个简单的Python代码生成器示例。
摘要由CSDN通过智能技术生成
在一个网元中，存在着各种“受管对象”（Managed Object）。每种“受管对象”都有自己的一组配置数据。比如，一个“学生”对象的配置数据定义如下： 
struct Student
{
   unsigned long  code;
   char           name[9];
   unsigned char  height;
   unsigned short score;
};
在“受管对象”配置修改的过程中，如果出了差错，应该可以将配置“回滚”到之前的值。所以，我们定义了如下模版来保存一个配置项。 
template <typename T>
struct ConfigValue
{
   ConfigValue(const T& defaultValue)
      : changed(false) 
      , currentValue(defaultValue)
      , oldValue(defaultValue)
      {}

   void set(const T& value)
   {
      if(currentValue == value) return;

      oldValue = currentValue;
      currentValue = value;
      changed = true;
   }

   const T& get() const
   { return currentValue; }

   const T& getOldValue() const
   { return changed ? oldValue : currentValue; }

   void resetStatus()
   { changed = false; }

   void revert()
   {
      if(not changed) return;

      currentValue = oldValue;
      changed = false;
   }

   bool isChanged() const
   { return changed; }

private:
   bool changed;
   T    currentValue;
   T    oldValue;
};
基于此模版，我们将“学生”的配置定义为： 
struct StudentConfig
{
   ConfigValue<unsigned long>       code;
   ConfigValue<FixedSizeString<8> > name;
   ConfigValue<unsigned char>       height;
   ConfigValue<unsigned short>      score;
};
通过SNMP的客户端，用户可以一次性修改某个“受管对象”的多个配置数据。比如，对于某个“学生”对象，用户可以同时修改他的“身高”和“总成绩”。所以我们定义了如下模版来保存由SNMP客户端而来的某个配置项： 
template <typename T>
struct OptionalConfigValue
{
   OptionalConfigValue() : specified(false) {}

   void set(const T& value)
   {
      this->value = value;
      specified   = true;
   }

   void updateTo(ConfigValue<T>& config) const
   {
      if(specified) config.set(value);
   }

private:
   bool specified;
   T    value;
};
以“学生”对象为例，相应的SNMP配置结构则定义为： 
struct StudentOptionalConfig
{
   OptionalConfigValue<unsigned long>       code;
   OptionalConfigValue<FixedSizeString<8> > name;
   OptionalConfigValue<unsigned char>       height;
   OptionalConfigValue<unsigned short>      score;
};
这样，StudentConfig应该提供一个update接口，来更新来自于SNMP客户端的配置数据。比如： 
struct StudentConfig
{
   StudentConfig()
      : code(0)
      , name("anon")
      , height(170)
      , score(0)
   {}

   void update(const StudentOptionalConfig& config)
   {
      config.code.updateTo(code);
      config.name.updateTo(name);
      config.height.updateTo(height);
      config.score.updateTo(score);
   }

   void revert()
   {
      code.revert();
      name.revert();
      height.revert();
      score.revert();
   }

   void configDone()
   {
      code.resetStatus();
      name.resetStatus();
      height.resetStatus();
      score.resetStatus(); 
   }

private:
   ConfigValue<unsigned long>       code;
   ConfigValue<FixedSizeString<8> > name;
   ConfigValue<unsigned char>       height;
   ConfigValue<unsigned short>      score;
};
从上述的实现中，我们能够发现强烈的重复模式：首先，所有的配置信息在不同的地方重复出现，其次，对于不同的配置信息进行相同的处理。

为了解决这样的重复问题，我们首先使用宏来定义“元数据”： 
// Student.h

DEFINE_CONFIG    (code,     unsigned long,  0)
DEFINE_CONFIG    (height,   unsigned char,  170)
DEFINE_CONFIG    (score,    unsigned short, 0)
DEFINE_STR_CONFIG(name,     8,              "anon")
而“魔法”的关键在于，如何来通过不同的宏定义来“解释”这些元数据。
比如，对于StudentOptionalConfig的定义，我们可以将其代码转化为： 
// StudentOptionalConfig.h

struct StudentOptionalConfig
{
#include <OptionalConfigDef.h>
#include "Student.h"
};
而OptionalConfig.h的定义为： 
// OptionalConfigDef.h


#ifdef DEFINE_CONFIG
#undef DEFINE_CONFIG
#endif

#define DEFINE_CONFIG(name, type, defaultValue) \
   OptionalConfigValue<type> name;


#ifdef DEFINE_STR_CONFIG
#undef DEFINE_STR_CONFIG
#endif

#define DEFINE_STR_CONFIG(name, size, defaultValue) \
   OptionalConfigValue<FixedSizeString<size> > name;
类似的，StudentConfig的定义则变为： 
// StudentConfig.h

struct StudentConfig
{
   StudentConfig() : 
   #include <DefaultValueDef.h>
   #include "Student.h"
   , dummy(true)
   {}

   void update(const StudentOptionalConfig& config)
   {
      #include <UpdateDef.h>
      #include "Student.h"
   }

   void revert()
   {
      #include <RevertDef.h>
      #include "Student.h"
   }

   void configDone()
   {
      #include <ConfigDoneDef.h>
      #include "Student.h"
   }

private:
   #include <ConfigDef.h>
   #include "Student.h"

   bool dummy;
};
而各个魔法头文件的定义分别为： 
// DefaultValueDef.h


#ifdef DEFINE_CONFIG
#undef DEFINE_CONFIG
#endif

#define DEFINE_CONFIG(name, type, defaultValue) \
   name(defaultValue),


#ifdef DEFINE_STR_CONFIG
#undef DEFINE_STR_CONFIG
#endif

#define DEFINE_STR_CONFIG(name, size, defaultValue) \
   name(defaultValue),
// UpdateDef.h


#ifdef DEFINE_CONFIG
#undef DEFINE_CONFIG
#endif

#define DEFINE_CONFIG(name, type, defaultValue) \
   config.name.updateTo(name);


#ifdef DEFINE_STR_CONFIG
#undef DEFINE_STR_CONFIG
#endif

#define DEFINE_STR_CONFIG(name, size, defaultValue) \
   config.name.updateTo(name);
// CofigDoneDef.h


#ifdef DEFINE_CONFIG
#undef DEFINE_CONFIG
#endif

#define DEFINE_CONFIG(name, type, defaultValue) \
   name.resetStatus();


#ifdef DEFINE_STR_CONFIG
#undef DEFINE_STR_CONFIG
#endif

#define DEFINE_STR_CONFIG(name, size, defaultValue) \
   name.resetStatus();
// RevertDef.h


#ifdef DEFINE_CONFIG
#undef DEFINE_CONFIG
#endif

#define DEFINE_CONFIG(name, type, defaultValue) \
   name.revert();


#ifdef DEFINE_STR_CONFIG
#undef DEFINE_STR_CONFIG
#endif

#define DEFINE_STR_CONFIG(name, size, defaultValue) \
   name.revert();
// ConfigDef.h


#ifdef DEFINE_CONFIG
#undef DEFINE_CONFIG
#endif

#define DEFINE_CONFIG(name, type, defaultValue) \
   ConfigValue<type> name;


#ifdef DEFINE_STR_CONFIG
#undef DEFINE_STR_CONFIG
#endif

#define DEFINE_STR_CONFIG(name, size, defaultValue) \
   ConfigValue<FixedSizeString<size> > name;
有了这些魔法定义文件，每个配置定义文件就呈现除了简单一致的规则，很容易就可以写出一个代码生成器，自动生成相关的代码。下面是一个Python的实现： 
import sys

optional_config_template = '''
#ifndef __%s_OPTIONAL_CONFIG_H__
#define __%s_OPTIONAL_CONFIG_H__

struct %sOptionalConfig
{
   #include <OptionalConfigDef.h>
   #include "%s.h"   
};

#endif
'''


config_template = '''

#ifndef __%s_CONFIG_H__
#define __%s_CONFIG_H__

struct %sConfig
{
   %sConfig()
   #include <DefaultValueDef.h>
   #include "%s.h"
   dummy(true)
   {}

   void update(const %sOptionalConfig& config)
   {
      #include <UpdateDef.h>
      #include "%s.h"
   }

   void configDone()
   {
      #include <ConfigDoneDef.h>
      #include "%s.h"
   }

   void revert()
   {
      #include <RevertDef.h>
      #include "%s.h"
   }

private:
   #include <ConfigDef.h>
   #include "%s.h"   

   bool dummy;
};

#endif
'''

def write_file(name, suffix, content) :
   file = open(name + suffix + ".h", "w")
   file.write(content)
   file.close()

def generate_optional_config(name) :
   write_file(name, "OptionalConfig", \
      optional_config_template % \
          ( name.upper(), name.upper(), name, name))

def generate_config(name) :
   write_file(name, "Config", \
      config_template % \
          ( name.upper(), name.upper() \
          , name, name, name, name, name, name, name, name))

def generate(name) :
   generate_optional_config(name)
   generate_config(name)

def usage() :
   print "usage: python config-gen.py config-name"

if __name__ == "__main__":
   if len(sys.argv) != 2:
      usage()
      sys.exit(1)

   generate(sys.argv[1])

godsme_yuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
宏元编程——逻辑控制——实现循环二
jakcymay的博客
03-08 558
之前在宏元编程粗略谈过宏的重入，即当宏在展开的时候遇到相同名字的宏会停止展开。 但是在宏元编程很多情况下会遇到，看过
宏元编程
jakcymay的博客
02-25 1495
宏元编程定义 宏元编程目的是利用宏在展开时候的特性减少重复代码，提供更高层的编程抽象。 宏的定义 宏有两种形式，带参数和不带参数 #define identifier replacement-list #define identifier(a1,a2,...an) replacement-list 说明：宏的实参
元编程
weixin_30675967的博客
08-11 81
在函数上添加包装器 问题： 　　你想在函数上添加一个包装器，增加额外的操作处理(比如日志、计时等) 解决方案： 　　如果你想使用额外的代码包装一个函数，可以定义一个装饰器函数，例如： 1 import time 2 from functools import wraps 3 4 5 def timethis(func): 6 @wra...
第十五章：元编程（一）
weixin_39061796的博客
10-29 340
元编程的引入 在引入元编程之前我们需要回顾下泛型编程，泛型编程是使用一套代码来处理不同的类型。但对于一些特殊的类型需要引入额外的处理逻辑，也就是在编译期引入操作程序的程序-元编程。或者更为通俗的讲，可以将元编程理解为编译期计算。 我们可以使用编译期计算来辅助运行期计算，但需要在概念上着重强调两点 这种辅助并不是简单地将整个运算一分为二 我们需要详细分析哪些内容可以放到编译期，哪些需要放到运行期。如果某种信息需要在运行期确定，那么通常无法利用编译期计算 元程序的形式通常有以下几种：模板， constexp
元编程艺术，第 1 部分: 元编程简介
weixin_33670713的博客
03-26 113
[原文链接] 　　编写程序来生成其他程序  　　目前应用最广泛的技术之一是编写生成其他程序或部分程序的程序。因此十分有必要学习为什么要采用元编程，以及元编程都有哪些组件（文本宏语言，专用代码生成器）。在本文中，您将学习到如何构建一个代码生成器，并详细了解如何使用 Scheme 编写对语言敏感的宏。 用来生成代码的程序有时被称为 元程序（meta...
c++宏元编程
zamzll的专栏
06-10 2993
1,定义一个宏函数,使得,func(x) = x-1?      最简单的, 如果x = 2则 #define func(x) 1 特化出来x,令 #define func_helper_2 1 #define func(x) func_helper_##x 这样在x=2时就成立了.推广到其他数字只需定义: #define func_helper_2 1 #define func_h
宏元编程——技术——变参宏
jakcymay的博客
03-01 733
1，获取变参数宏的个数 #define TL_VARIADIC_SIZE(...) TL_CAT(TL_VARIADIC_SIZE_I(__VA_ARGS__, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,),) #define TL_VARIADIC_SIZE_I(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, size,
宏元编程——代码生成
jakcymay的博客
03-09 1572
通过宏来自动生成代码，可以提高代码可读性，降低代码维护成本，减少重复代码输入。
宏元编程——逻辑控制——实现循环一
jakcymay的博客
03-01 776
循环宏定义 #define TL_WHILE(pred,op,state) while-body pred是一个二元的宏形式是pred(d，state)，当pred返回0的时候循环终止 op是一个二元的宏形式是op(d，state)，它返回值是state_new state代表初始状态 TL_WHILE宏的展开形式如下： op(d, ... op(d, op(d
C++模板元编程
D_Guco的专栏
12-17 2283
所谓元编程就是编写直接生成或操纵程序的程序，C++ 模板给 C++ 语言提供了元编程的能力，模板使 C++ 编程变得异常灵活，能实现很多高级动态语言才有的特性（语法上可能比较丑陋，一些历史原因见下文）。普通用户对 C++ 模板的使用可能不是很频繁，大致限于泛型编程，但一些系统级的代码，尤其是对通用性、性能要求极高的基础库（如 STL、Boost）几乎不可避免的都大量地使用 C++ 模板，一个稍有规
C++之模板元编程
w1012747007的专栏
07-27 1156
关于模板原编程知识强烈推荐：http://blog.jobbole.com/83461/，非常好！ 这篇文章通过举例详细介绍了模板的模板参数，模板特例化，模板实例化以及编译链接等模板基础知识。 本文主要分析文章中的模板元编程例子： 首先复述一下模板元编程，以下标红或者加粗的地方是模板元编程的精髓： 从编程范型（programming paradigm）上来说，C++
巧妙利用宏定义-实现宏定义重载
qq_15978101的博客
05-17 516
//用于实现根据宏参数个数重载宏定义 #define PRIVATE_MACRO_VAR_ARGS_IMPL_COUNT(_1,_2,_3,_4,_5,_6,_7,_8,_9, N, ...) N #define PRIVATE_MACRO_VAR_ARGS_IMPL(args) PRIVATE_MACRO_VAR_ARGS_IMPL_COUNT args #define COUNT_MACRO_VAR_ARGS(...) PRIVATE_MACRO_VAR_ARGS_IMPL((__VA_ARGS_.
c++带参同名宏函数“重载”及嵌套的使用以及一些问题
weixin_44022134的博客
03-06 822
在c++中，宏函数是可以根据参数数量来“重载”的，可以根据宏参数个数来决定对应的宏定义展开，但是当参数较多时，宏函数有时候会变得比较长和复杂
宏定义与函数重载
猴子2333博客
06-24 1038
在软件开发过程中，经常有一些常用或者通用的功能或者代码段，这些功能既可以写成函数，也可以封装成为宏定义。那么究竟是用函数好，还是宏定义好？这就要求我们对二者进行合理的取舍。 宏定义中允许包含两行以上命令的情形，此时必须在最右边加上”\”且该行”\”后不能再有任何字符，连注释部分都不能有，下面的每行最后的一定要是”\”,”\”后面加一个空格都会报错，更不能跟注释。 我们来看一个例子，比较两个数或者表...
重载宏函数
zyb408815041的博客
12-09 510
参考: http://blog.nemoge.com/trick-for-overload-macro-function-in-c/ #include #define F(...) f(__VA_ARGS__) int f(int a, int b, int c) { return a + b + c; } int f(int a, int b)
C++ 支持宏重载效果
零落年华的专栏
06-14 2195
C++宏默认是不支持重载的，但可以通过特殊方法让宏支持重载。 可能你要问，支持宏重载有什么用处，那么，就以实例来尝试宏的重载。 为了要实现类的动态创建，我还想构建类的继承关系图，为了简化注册，所以我需要用宏来简化注册。 我需要以下宏来支持： REG_CREATE1(className) REG_CREATE2(className， baseName1) REG_CREATE3(className， baseName1, baseName2) C++支持多继承，但为了方便，我不希望每次注册的时.
消息队列参数设置
最新发布
hulufeng1203的专栏
03-07 648
根据队列的特性可知,如果阻塞队列中一个消息阻塞了,那么所有消息将会被阻塞,如果使用默认设置,concurrentConsumer=1,prefetchCount=250,那么当消费者队列中有一个消息由于某种原因阻塞了,那么该消息的后续消息同样不能被消费.为了防止这种情况的发生,我们可以增大concurrentConsumer的设置,使多个消费者可以并发消费.而prefetchCount该如何设置呢?(1)消费者的速度大大慢于生产者的速度,速度不匹配引起的堆积。(3)消费者业务处理异常导致的消息堆积。
c++宏编程一览
CDScan的专栏
11-24 5462
 基础部分 1. __VA_ARGS__: 用来替换任意参数部分, 相当于c语言中的va_list;  例:#define OUT(...)    printf(__VA_ARGS__) 2. 宏从内向外展开(例外情况见4)原因是, 当一个红的参数也是宏的时候, 它会尝试先展开它的参数;  例:max(max(1, 3), 2) => max(3, 2) => 3
宏定义处理代码重复
xt18971492243的博客
07-06 1296
在函数外宏定义后，使用IF_NULL2 ()就可以完成替换；
动态负载平衡遗传算法优化视界覆盖问题
视界覆盖问题涉及在地理空间中找到最优的点源网络部署，以最大化覆盖范围，这被证明是一个NP完全问题，意味着目前缺乏有效的近似解决方案。为了提高问题求解效率，研究者提出了一种基于动态负载平衡的并行遗传算法。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值