Dereferencing elements of a struct

Projects Programming
1

I'm not clear on the syntax... how do I dereference a member variable in a struct:

byte tempSensor[][8] = {                           // Array of sensor ID's
  {0x28, 0xFF, 0x0D, 0x4C, 0x05, 0x16, 0x03, 0xC7},
  {0x28, 0xFF, 0x25, 0x1A, 0x01, 0x16, 0x04, 0xCD},
  {0x28, 0xFF, 0x89, 0x19, 0x01, 0x16, 0x04, 0x57},
  {0x28, 0xFF, 0x21, 0x9F, 0x61, 0x15, 0x03, 0xF9},
  {0x28, 0xFF, 0x16, 0x6B, 0x00, 0x16, 0x03, 0x08},
  {0x28, 0xFF, 0x90, 0xA2, 0x00, 0x16, 0x04, 0x76},
  {0x10, 0xE9, 0x6B, 0x0A, 0x03, 0x08, 0x00, 0xAC},
  {0x10, 0x44, 0x4E, 0x0B, 0x03, 0x08, 0x00, 0x1F}
};

struct Sensors{
    float T;
    byte address[8];
};

Sensors mySensors[8];

Sensors* bus1[] = {&mySensors[0], &mySensors[1], &mySensors[2], &mySensors[3]}; // group sensors by which pin they're connected to
Sensors* bus2[] = {&mySensors[4], &mySensors[5], &mySensors[6]};
Sensors* bus3[] = {&mySensors[7]};



void setup() 
{
    Serial.begin(9600);
    for(int i = 0; i < 8; i++)
    {
        for(int j = 0; j < 8; j++)
        {
            mySensors[i].address[j] = tempSensor[i][j];
        }
    }
}


void loop() 
{
  myFunction(bus1, sizeof(bus1)/sizeof(bus1[0]));
}

void myFunction(struct Sensors** ptrArray, size_t size)  // pointer to array of pointers
{
    for(int i = 0; i < size; i++)
    {
        *ptrArray[i]->T = float(i); // <<<<<<  HERE  (just stuffing any old number here)
    }
}

*ptrArray[i]->T = float(i);

gives error:

error: invalid type argument of unary '*' (have 'float')
2

For struct you use .
For pointer to struct you use ->

3

MarkT:
For struct you use .
For pointer to struct you use ->

not getting you:

*ptrArray[i].T = float(i);

Arduino: 1.6.3 (Mac OS X), Board: "Arduino Nano, ATmega328"

passingStructs.ino: In function 'void myFunction(Sensors**, size_t)':
passingStructs.ino:47:21: error: request for member 'T' in '*(ptrArray + ((sizetype)(((unsigned int)i) * 2u)))', which is of pointer type 'Sensors*' (maybe you meant to use '->' ?)
Error compiling.
4

If you have something of type struct, use .
If you have something of type pointer-to-struct, use ->

struct foo a ;  // a is of type struct
struct foo * b = &a ;  // b is of type pointer to struct

a.x   // extract field from struct
b->x  // deference pointer and extract field
5

oh, I got it!

ptrArray[i]->T = float(i);

no need for the leading * dereference, I guess!

6

You don't have to guess, I told you -> deferences and extracts a field. This is the sort of thing
stackoverflow.com would answer in milliseconds BTW!

7

MarkT:
You don't have to guess, I told you -> deferences and extracts a field. This is the sort of thing
stackoverflow.com would answer in milliseconds BTW!

just a figure of speech :-[

I did search stackoverflow, but didn't find it.

I appreciate your help.

8

One follow-up question:

Can I get the number of pointers pointed to in the following?

I want to assign values to certain members of an array, broken up into several arrays as follows:

float x[10];

float* floatPtr0[] = {&x[0], &x[1], &x[2], &x[3], &x[4]};
float* floatPtr1[] = {&x[5], &x[6], &x[7]};
float* floatPtr2[] = {&x[8], &x[9]};
float* floatPtr3[] = {&x[2]};

float** floatPtrArray[] = {floatPtr0, floatPtr1, floatPtr2, floatPtr3};  // array of pointers to arrays of pointers

void setup() 
{
  Serial.begin(9600);
  //Serial.println(sizeof(floatPtrArray)/sizeof(floatPtrArray[0]));
}

void loop() 
{
  for(int i = 0; i < sizeof(floatPtrArray)/sizeof(floatPtrArray[0]); i++)  // works correctly = 4 in this example
  {
    
    Serial.println(sizeof(**floatPtrArray[i])/sizeof(float*)); // not what I want
    
    myFunction(floatPtrArray[i], sizeof(**floatPtrArray[i])/sizeof(float*)); // for HERE<<<<<
    
  }
  for(int i = 0; i < sizeof(x)/sizeof(x[0]); i++)
  {
    //Serial.println(x[i]);
  }
  delay(5000);
}

void myFunction(float** ptrArray, size_t size)
{
  for(int i = 0; i < size; i++)
  {
    *ptrArray[i] = float(i);  // arbitrary assignment
  }
}
9

BulldogLowell:
Can I get the number of pointers pointed to in the following?

In that situation it is your responsibility.

size_t floatPtrArrayCount[] = 
  {
    sizeof(floatPtr0) / sizeof(floatPtr0[0]), 
    sizeof(floatPtr1) / sizeof(floatPtr0[1]), 
    sizeof(floatPtr2) / sizeof(floatPtr0[2]), 
    sizeof(floatPtr3) / sizeof(floatPtr0[3])
  };

However, I suggest merging the arrays (floatPtrArray and floatPtrArrayCount) using a struct.

10 
    Serial.println(sizeof(**floatPtrArray[i])/sizeof(float*)); // not what I want

Once you have a pointer to an array, rather than the array itself, you can no longer derive the size of the array that it points to. "sizeof" is a compile-time operator, so its arguments cannot be dereferenced.

This code looks very weird. If you have an array, you might as well store indices to the array, rather than pointers.