Question

假设我在一个系统中有3个可以调用或不调用的函数。稍后在我的算法中（请参见下面的“ myMainFunction（）”），我想知道是否调用了所有函数。

实际上是为了跟踪是否调用了我的函数，我使用了一个设置16位字段的辅助函数：

static void SetBitField(u16 p_Bitfield, u8 Bit)
{
   u16 tmp_Bitmask;

   tmp_Bitmask = (u16)((u16)(1) << (u16)(Bit));

   *p_Bitfield |= tmp_Bitmask;

}

现在我正在执行以下操作：

static u16 BitMask;

#define SHIFT_0     0
#define SHIFT_1     1
#define SHIFT_2     2

#define MASK        7

fun1()
{
/*doing some stuff*/

SetBitField(&BitMask,SHIFT_0)

}

fun2()
{

/*doing some stuff*/

SetBitField(&BitMask,SHIFT_1)
}

fun3()
{

/*doing some stuff*/

SetBitField(&BitMask,SHIFT_2)
}

现在在主函数中，我可以检查所有函数是否都被调用

    myMainFunction()
    {

    /*doing some stuff*/

    if ((BitMask & MASK) == MASK)
    {
        /*all functions are called*/
    }

    /*doing some stuff*/
}

到目前为止还好。但是最后，无论调用函数的顺序如何，我都将获得相同的BitMask。但是如何以稍后可以检查是否按特定顺序调用函数的方式修改SetBitField（）函数。例如要检查是否调用了func1（）-> func2（）-> func3（），而不是例如检查func2（）-> func1（）-> func3（）？

有什么主意吗？

Answer 1

“您无法通过查看轨道来了解火车的行驶方向”，也无法通过查看位来了解调用函数的顺序。他们只会告诉您该函数已被调用，而不会告诉您顺序。

但是以下内容确实存在：

struct BITMASK {
    unsigned int b1:3;
    unsigned int b2:3;
    unsigned int b3:3;
    unsigned int b4:3;
    unsigned int b5:3;
    unsigned int b6:3;
    unsigned int b7:3;
} myBits;
int counter;

static void SetBitField(u8 Bit)
{
    switch (Bit) {
    case 0: myBits.b1= ++counter; return;
    case 1: myBits.b2= ++counter; return;
    case 2: myBits.b3= ++counter; return;
    case 3: myBits.b4= ++counter; return;
    case 4: myBits.b5= ++counter; return;
    case 5: myBits.b6= ++counter; return;
    case 6: myBits.b7= ++counter; return;
    }
}

因此，这里您使用三个位（最多七个函数调用）来保存一个数字，该数字是调用顺序。

Answer 2

Given 3 functions and shift values (1, 2, 3).

If you apply this rule upon function invocation:

set the most significant bit, then shift right by the respective value.

For the given (order), you will get [these bits]:

(1, 2, 3) [0, 0, 0, 1, 0, 1, 1, 0]
(1, 3, 2) [0, 0, 1, 0, 0, 1, 1, 0]
(2, 1, 3) [0, 0, 0, 1, 1, 0, 1, 0]
(2, 3, 1) [0, 1, 0, 0, 1, 0, 1, 0]
(3, 1, 2) [0, 0, 1, 1, 0, 0, 1, 0]
(3, 2, 1) [0, 1, 0, 1, 0, 0, 1, 0]

The python script that generated the bits for example purposes:

import itertools                             

def mark(v, x):                              
  v[0] = 1                                   
  v = [0] * x + v[:-x]                       
  return v                                   

for x in itertools.permutations([1,2,3]):    
  v = [0] * 8                                
  for xx in x:                               
    v = mark(v, xx)                          
  print x, v

如何以特定顺序设置位域并在以后针对该顺序进行检查

2 个答案: