Question

微控制器有许多引脚，每个引脚都定义为

const Leg PA29 { PIOA, BIT(29) };   // struct Pin is already taken
// ... about 120 more: 4 port x 32 pin

我写了一个简单的define来制作更短格式的别名

#define P(Port,PinN)  \
    const Leg P##Port##PinN { PIO##Port, BIT(PinN) }

将其用作

P(D,2);  //produces PD2 with { PIOD, BIT(2) }

尼斯。
现在我需要 - 不要为4个端口调用P 120次，每个端口有32个引脚。我希望看到像

这样的东西

FOR_EACH( X in A,B,C,D ) \
  FOR_EACH( i in 0..31 ) \
    P(X,i);

请不要建议TCL，python等生成C ++代码我找到了一个answer，但要理解如何在我的情况下使用它是很复杂的。

主要思想是避免使用复制粘贴的120行。所有120多个引脚应该在大约10行中定义。

UPD。如何定义BIT：

///@param n is value from 0 to number of bits in unsigned value
template<typename UnsignedIntegerT=unsigned>
constexpr UnsignedIntegerT BIT(UnsignedIntegerT n){ return 1<<n; }

UPD2。最小的例子

///////////////////
// Vendor provides something like:
///////////////////

struct Pio
{
    unsigned reg1;
    unsigned reg2;
    unsigned reg3;
    //...
    unsigned regN;
};


// values not from datasheet but from lantern
#define PIOA  ((Pio*)0xAABB6789)
#define PIOB  ((Pio*)0xAABB2569)
#define PIOC  ((Pio*)0xAABB2566)
#define PIOD  ((Pio*)0xAABB2323)
//...



/////////////
// Kyb's code
/////////////

class Leg 
{
public:
    Pio *pio;
    unsigned pinN;
//methods...
};


///@param n is value from 0 to number of bits in unsigned value
template<typename UnsignedIntegerT=unsigned>
constexpr UnsignedIntegerT BIT(UnsignedIntegerT n){ return 1u<<n; }


//////////////
// Now need to define 120+ pins-legs

// like this
const Leg PA29 { PIOA, BIT(29) };

// or with shortener alias

/// Alias to shortly produce leg definition
/// Example: `P(A,2)` will define `PA2` with proper PIO and bit.
#define P(Port,PinN)  \
        const Leg P##Port##PinN { PIO##Port, BIT<unsigned>(PinN) }

//P(D,4);  //produces PD4
//P(C,3);

Answer 1

你没有发布一个真正极小的例子。所以这是最好的猜测。但是如果你正在使用C ++ 14，并且你的类型是constexpr可构造的，那么在我看来你应该尽可能地取消预处理器，并且只使用变量模板：

enum port {A, B, C, D};

template<port>
struct PIO_ID;
template<> struct PIO_ID<A>{ static constexpr auto value = PIOA; };
template<> struct PIO_ID<B>{ static constexpr auto value = PIOB; };
template<> struct PIO_ID<C>{ static constexpr auto value = PIOC; };
template<> struct PIO_ID<D>{ static constexpr auto value = PIOD; };

template<port P>
constexpr auto PIO = PIO_ID<P>::value;

template<port PORT, int PIN_NUM>
constexpr Leg P{ PIO<PORT> , BIT(PIN_NUM) };

就是这样。现在，您可以将这些常量称为P<A, 0>，依此类推。

Answer 2

你真的需要const Leg PA29（并且可能在其他地方引用PA29吗？

如果您准备撰写PA[29]且PA属于具有合适operator []的类型，那么您只需PA，PB ，PC和PD来定义（我可能甚至不会使用预处理器定义）。

或者，Boost Preprocessor library提供循环。

Answer 3

Boost preprocessor library的解决方案：

#include "Pio.hpp"  // Has Leg and BIT definitions
#include "boost/preprocessor.hpp"  //#include "boost/preprocessor/iteration"


/// Alias to shortly produce leg definition
/// The P(A,2) will define PA2 with proper PIO and bit.
#define P(Port,PinN)  \
        const Leg P##Port##PinN { PIO##Port, BIT<unsigned>(PinN) }


#define PA(n)  P(A,n)
#define PB(n)  P(B,n)
#define PC(n)  P(C,n)
#define PD(n)  P(D,n)


#define BOOST_PP_LOCAL_MACRO(n)   PA(n);
#define BOOST_PP_LOCAL_LIMITS     (0, 31)
#include BOOST_PP_LOCAL_ITERATE()  //??=include BOOST_PP_LOCAL_ITERATE()  //-Wtrigraphs

#define BOOST_PP_LOCAL_MACRO(n)   PB(n);
#define BOOST_PP_LOCAL_LIMITS     (0, 31)
#include BOOST_PP_LOCAL_ITERATE()

#define BOOST_PP_LOCAL_MACRO(n)   PC(n);
#define BOOST_PP_LOCAL_LIMITS     (0, 31)
#include BOOST_PP_LOCAL_ITERATE()

#define BOOST_PP_LOCAL_MACRO(n)   PD(n);
#define BOOST_PP_LOCAL_LIMITS     (0, 31)
#include BOOST_PP_LOCAL_ITERATE()

这很好用。但是由于没有什么不便：IDE会强调PA5而其他人则将其作为未解决的符号。

使用C ++预处理器定义多个类似的变量

UPD2。最小的例子

3 个答案: