Question

I have a program that compares variables from two structs and sets a bit accordingly for a bitmap variable. I have to compare each variables of the struct. No. of variables in reality are more for each struct but for simplicity I took 3. I wanted to know if i can create a macro for comparing the variables and setting the bit in the bitmap accordingly.

#include<stdio.h>


struct num 
{
   int a;
   int b;
   int c;
};

struct num1
{
   int d;
   int e;
   int f;
};

enum type
{
   val1 = 0,
   val2 = 1,
   val3 = 2,
};
int main()
{
  struct num obj1;
  struct num1 obj2;
  int bitmap = 0;

  if( obj1.a != obj2.d)
  {
      bitmap  = bitmap | val1;
  }
  if (obj1.b != obj2.e)
     bitmap = bitmap | val2;

  printf("bitmap - %d",bitmap);
  return 1;


}

can i declare a macro like…

#define CHECK(cond)
  if (!(cond))
    printf(" failed check at %x: %s",__LINE__, #cond);
    //set the bit accordingly

#undef CHECK

Answer 1

With a modicum of care, you can do it fairly easily. You just need to identify what you’re comparing and setting carefully, and pass them as macro parameters. Example usage:

CHECK(obj1.a, obj2.d, bitmap, val1);
CHECK(obj1.b, obj2.e, bitmap, val2);

This assumes that CHECK is defined something like:

#define STRINGIFY(expr) #expr

#define CHECK(v1, v2, bitmap, bit) do \
    { if ((v1) != (v2)) \
         {   printf("failed check at %d: %s\n", __LINE__, STRINGIFY(v1 != v2)); \
             (bitmap) |= (1 << (bit)); \
         } \
    } while (0)

You can lay the macro out however you like, of course; I’m not entirely happy with that, but it isn’t too awful.

Demo Code

Compilation and test run:

$ gcc -Wall -Wextra -g -O3 -std=c99 xx.c -o xx && ./xx
failed check at 40: obj1.a != obj2.d
failed check at 42: obj1.c != obj2.f
bitmap - 5
$

Actual code:

#include <stdio.h>

struct num 
{
   int a;
   int b;
   int c;
};

struct num1
{
   int d;
   int e;
   int f;
};

enum type
{
   val1 = 0,
   val2 = 1,
   val3 = 2,
};

#define STRINGIFY(expr) #expr

#define CHECK(v1, v2, bitmap, bit) do \
    { if ((v1) != (v2)) \
      {   printf("failed check at %d: %s\n", __LINE__, STRINGIFY(v1 != v2)); \
      (bitmap) |= (1 << (bit)); \
      } \
    } while (0)


int main(void)
{
    struct num  obj1 = { 1, 2, 3 };
    struct num1 obj2 = { 2, 2, 4 };
    int bitmap = 0;

    CHECK(obj1.a, obj2.d, bitmap, val1);
    CHECK(obj1.b, obj2.e, bitmap, val2);
    CHECK(obj1.c, obj2.f, bitmap, val3);

    printf("bitmap - %X\n", bitmap);
    return 0;
}

Clearly, this code relies on you matching the right elements and bit numbers in the invocations of the CHECK macro.

It’s possible to devise more complex schemes using offsetof() etc and initialized arrays describing the data structures, etc, but you’d end up with a more complex system and little benefit. In particular, the invocations can’t reduce the parameter count much. You could assume ‘bitmap’ is the variable. You need to identify the two objects, so you’ll specify ‘obj1’ and ‘obj2’. Somewhere along the line, you need to identify which fields are being compared and the bit to set. That could be some single value (maybe the bit number), but you’ve still got 3 arguments (CHECK(obj1, obj2, valN) and the assumption about bitmap) or 4 arguments (CHECK(obj1, obj2, bitmap, valN) without the assumption about bitmap), but a lot of background complexity and probably a greater chance of getting it wrong. If you can tinker with the code so that you have a single type instead of two types, etc, then you can make life easier with the hypothetical system, but it is still simpler to handle things the way shown in the working code, I think.

I concur with gbulmer that I probably wouldn’t do things this way, but you did state that you had reduced the sizes of the structures dramatically (for which, thanks!) and it would become more enticing as the number of fields increases (but I’d only write out the comparisons for one pair of structure types once, in a single function).

You could also revise the macro to:

#define CHECK(cond, bitmap, bit) do \
    { if (cond) \
      {   printf("failed check at %d: %s\n", __LINE__, STRINGIFY(cond)); \
          (bitmap) |= (1 << (bit)); \
      } \
    } while (0)

CHECK(obj1.a != obj2.d, bitmap, val1);
...
CHECK((strcmp(obj3.str1, obj4.str) != 0), bitmap, val6);

where the last line shows that this would allow you to choose arbitrary comparisons, even if they contain commas. Note the extra set of parentheses surrounding the call to strcmp()!