C中联合后的“++”是什么意思？

Question

Here's the code

int AreSymEquivalent_hkl(const T_SgInfo *SgInfo, int h1, int k1, int l1,
                                                 int h2, int k2, int l2)
{
  int     iList, mh2, mk2, ml2, hm, km, lm;
  T_RTMx  *lsmx;


  mh2 = -h2;
  mk2 = -k2;
  ml2 = -l2;

  /* check list of symmetry operations */

  lsmx = SgInfo->ListSeitzMx;

  for (iList = 0; iList < SgInfo->nList; iList++, lsmx++)
  {
    hm = lsmx->s.R[0] * h1 + lsmx->s.R[3] * k1 + lsmx->s.R[6] * l1;
    km = lsmx->s.R[1] * h1 + lsmx->s.R[4] * k1 + lsmx->s.R[7] * l1;
    lm = lsmx->s.R[2] * h1 + lsmx->s.R[5] * k1 + lsmx->s.R[8] * l1;

    if      ( h2 == hm &&  k2 == km &&  l2 == lm)
      return  (iList + 1);

    else if (mh2 == hm && mk2 == km && ml2 == lm)
      return -(iList + 1);
  }

  return 0;
}

It's a function defined from a quite famous package 'sginfo' in the area of computational crystallography. (You can download from here if you want: https://github.com/rwgk/sginfo/tree/master/sginfo_1_01 ) So i'm sure there's no bug in it. The question is in the lines

  lsmx = SgInfo->ListSeitzMx;

  for (iList = 0; iList < SgInfo->nList; iList++, lsmx++)

Where "SgInfo" is a big struct I did not put it here, containing "ListSeitzMx" -- an attribute of a union named "T_RTMx" which consists some matrices information. The definition is as follows:

typedef union
  {
    struct { int R[9], T[3]; } s;
    int                        a[12];
  }
  T_RTMx;

That's the part confuses me, "++" after a union. What I know is that the value of int before "++" adds to 1, but the union type makes no sense. Or I have made a big mistake of the whole thing? That "lsmx" is not a union or something... As a beginner of C, I have tried to write a small test script on this question but the bugs made me crazy. So I finally decided to publish this question...

Answer 1

lsmx++

is equivalent to

( orig = lsmx, lsmx = lsmx + 1, orig )

In other words,

• lsmx++ adds one to lsmx (as if you had done ( lsmx = lsmx + 1 ).

• lsmx++ evaluates to the original value of lsmx , but that is discarded in your code.

lsmx is a pointer. Adding 1 to a pointer increases the address by the size of the pointed thing ( sizeof(*lsmx) ).

For example,

T_RTMx foo[5] = ...;
T_RTMx *lsmx = foo;   # Same as &( foo[0] )   # Points to foo[0]
lsmx++;                                       # Points to foo[1]
lsmx += 2;                                    # Points to foo[3]

Keep in mind that a[b] is completely equivalent to *(a+b) .

Answer 2

You are actually not adding to the union. You are adding to the address.

Consider a similar situation:

struct abc {
    int a, b, c;
    //Lots more nonsense
};

Now,

struct abc z;
struct abc *a;
a = &z

This tells that a stores address of struct abc type.

Now let's revise how pointers work.

Let's suppose z resides at a location 1000 . a stored that value. When I do *a , I refer to memory location 1000 upto sizeof(struct abc) . As a is a pointer to the type struct abc , you can do:

a->c = 2;

or something like that.

When you say:

int *b;

It practically can store address of any other type. If you really like to be adventurous, you can do this:

b = &z;

You may or may not receive warnings depending on your compiler.

When I store &z , the only thing the compiler does is treat the value at the address of z as an int . So b has the value 1000 .

Now when you do *b , you refer to the address 1000 upto sizeof(int) .

Concluding this,

b++;

This would just do 1000 + sizeof(int) , and reach to next int .

a++;

would do 1000 + sizeof(struct abc) .