How can i pass structs across files by value - c++

Question

I’m able to produce a compilable piece of code that will pass structs to functions, however my code just falls apart when i’m trying to use ‘pass by value’.
I’ve looked at how to use the same formatted struct across multiple files, but i’m not sure if it’s any different when passing functions by value?
Note: this is written in the arduino IDE in C++
my code for passing by address follows:
passingStructs.ino
#include "a.h"
#include "b.h"
myStruct volatile structure1;
void setup() {
}
void loop() {
structure1.foo = 7;
structure1.bar = 11;
int lower = minusData(&structure1);
int higher = addData(&structure1);
}
a.h:
#include "b.h"
#ifndef __a_h
#define __a_h
//prototype functions
int addData(struct myStruct *structureC);
#endif //__a_h
a.cpp:
#include "a.h"
#include "b.h"
int addData(struct myStruct *structureC) {
int x = structureC->foo;
int y = structureC->bar;
return (x + y);
}
b.h:
#ifndef __b_h
#define __b_h
//Define structure
typedef struct myStruct {
int foo;
int bar;
};
//Prototype functions
int minusData(struct myStruct *structureC);
#endif //__b_h
b.cpp:
#include "b.h"
myStruct structureC;
int minusData(struct myStruct *structureC) {
int x = structureC->foo;
int y = structureC->bar;
return (x - y);
}
however if i use
int higher = addData(structure1);
in the .ino file and
int addData(struct myStruct structureC) {
int x = structureC.foo;
int y = structureC.bar;
return (x + y);
}
in the a.cpp file with the same prototype in the header file, the compiler rejects the code saying
no matching function for call to ‘myStruct::myStruct(volatile myStruct&)’
any ideas?

Answer 1

C++ will generate default constructors and a copy operator for structs and classes.
For your myStruct these implicit functions would be:
struct myStruct {
myStruct() {} // <-- implicit default constructor.
myStruct(const myStruct& other) // <-- implicit copy contructor
{
foo = other.foo;
bar = other.bar;
}
myStruct& operator = (const myStruct& other) // <-- implicit copy operator
{
foo = other.foo;
bar = other.bar;
return *this;
}
int foo;
int bar;
};
Note that the copy constructor and operator expect a const myStruct& parameter. The volatile keyword in your definition of myStruct volatile structure1; prevents parameter matching.
You'd have to explicitly declare a copy operator and/or constructor that accept a const volatile myStruct& to make your code compile.
volatile data needs special handling by the compiler's optimizer. That's why the volatile keyword is important here. You should really consider whether your data really needs this qualifier. On the Arduino, there is only one case where this keyword is needed, that is when the data is modified by an interrupt routine.
Alternatively, you can define functions that accept a volatile reference or pointer to data:
struct MyStruct // I suggest you use this syntax for declarting structures
{ // So you don't ghave to repeat the struct keyword everywhere.
myStruct(const myStruct& other)
{
foo = other.foo;
bar = other.bar;
}
myStruct(const volatile myStruct& other)
{
foo = other.foo;
bar = other.bar;
}
int foo, bar;
};
int addData(volatile const myStruct* structureC)
{
return structureC->foo + structureC->bar;
}
int addData(volatile const myStruct& structureC)
{
return structureC.foo + structureC.bar;
}
int addDataByCopy(myStruct structureC)
{
return structureC.foo + structureC.bar;
}
// ...
volatile myStruct my;
void loop()
{
my.foo = 1;
my.bar = 1;
int x = addData(my); // by const reference.
// or
int y = addData(&my); // by pointer.
// or
int z = addDataByCopy(my); // by copy
}