Question

我能够生成一个可编译的代码段，它将结构传递给函数，但是当我尝试使用'按值传递'时，我的代码就崩溃了。

我看过如何在多个文件中使用相同的格式化结构，但是我不确定按值传递函数时是否有任何不同？

注意：这是用C ++中的arduino IDE编写的

我的传递地址的代码如下：

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);
    }

然而，如果我使用 int higher = addData（structure1）; 在.ino文件和

int addData(struct myStruct structureC) {

  int x = structureC.foo;
  int y = structureC.bar;

  return (x + y);
}

在头文件中具有相同原型的a.cpp文件中，编译器拒绝代码

no matching function for call to ‘myStruct::myStruct(volatile myStruct&)’

任何想法？

Answer 1

C ++将为结构和类生成默认构造函数和复制运算符。

对于myStruct，这些隐式函数将是：

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;
};

请注意，复制构造函数和运算符需要const myStruct&参数。 volatile定义中的myStruct volatile structure1;关键字会阻止参数匹配。

您必须明确声明接受const volatile myStruct&的复制运算符和/或构造函数才能编译代码。

volatile数据需要编译器的优化器进行特殊处理。这就是volatile关键字在这里很重要的原因。您应该考虑您的数据是否确实需要此限定符。在Arduino上，只有一种情况需要使用此关键字，即中断例程对数据进行修改时。

或者，您可以定义接受易失性引用或指向数据的指针的函数：

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
}

如何按值传递跨文件的结构

1 个答案: