0

我有一个函数检查，它接受一个布尔值作为参数，使用布尔值然后改变它。我总是给这个函数传递一个全局变量，比如：

check(4, some_global_boolean, 'a');

并且我希望在调用“检查”后保留对变量的更改。现在，更改并没有超出这个函数调用。我该怎么做呢？

boolean check(int key, boolean prev_key_high, char c){

 if (key == LOW) {
    if ( prev_key_high){
      prev_key_high = false;
      Serial.println(c);
      return true;
}
  }

  else {
    prev_key_high = true;
    return false;
  }
}
4

6 回答 6

2

此外，如果您的变量在全局范围内，您可以将其从参数列表中删除并直接访问它，这样它就不会出现在本地范围内。例如：

int globalInt;

void incGlobal() {
    globalInt++;
}

int main() {
    globalInt = 0;
    printf("%d\n", globalInt);
    incGlobal();
    printf("%d\n", globalInt);
    incGlobal();
    printf("%d\n", globalInt);
    incGlobal();
}

印刷

0
1
2
于 2013-09-19T19:56:12.110 回答
1

您应该传递指针，但您必须将所有用法更改为取消引用的指针，如下所示：

boolean check(int key, boolean *prev_key_high, char c){

    ...
    if (*prev_key_high)
    ...
    *prev_key_high = true;
    ...
于 2013-09-19T19:48:58.503 回答
0

您无需将全局作为参数传递给您的函数！而是直接访问它。将 global 作为参数传递会创建全局变量的本地副本，该副本位于函数范围内。

于 2013-09-19T20:21:17.560 回答
0

谢谢西蒙。这是新代码：

  check(key_a, &prev_key_a_high, 'a');

boolean check(int key, boolean *prev_key_high, char c){

 if (key == LOW) {
    if ( *prev_key_high){
      *prev_key_high = false;
      Serial.println(c);
      return true;
    }
  }

  else {
    *prev_key_high = true;
    return false;
  }



}
于 2013-09-19T19:49:20.923 回答
0

全局布尔值的变化不会持续，因为它是按值传递的。当参数按值传递给函数时，函数会创建变量的本地副本并对本地副本进行更改。一旦程序超出函数范围，这个局部变量就会耗尽内存。使用指针应该可以解决问题。试试下面的..

boolean check(int key, boolean* prev_key_high, char c){
  if (key == LOW) {
    if ( *prev_key_high){
      *prev_key_high = false;
      Serial.println(c);
    return true;
    }
   }

    else {
      *prev_key_high = true;
      return false;
    }
  }

当你调用函数时：

check(4, &some_global_boolean, 'a');
于 2013-09-19T19:54:45.137 回答
0

首先，您需要了解作用域在 C 中是如何工作的，以及变量是如何传递给函数的。Local Scope > Global Scope，例如，如果您有一个名为“variable”的全局变量，以及一个带有一个也名为“variable”的变量的函数，那么您将使用它的本地副本。

现在，考虑到这一点，想想这一点，当您将参数传递给函数时，您实际上是在本地范围内制作了变量的副本。所以在你的功能中：

check(4, some_global_boolean, 'a');

当你定义函数时，你给每个参数一个名字，对吗？所以当你调用一个函数时，你会根据函数签名将每个参数实例化为一个变量（定义类型）。有点这样：argument1 = value1，argument2 = value 2，...，argumenn = valuen

现在，让我们把它带到你的函数中： boolean check(int key, boolean prev_key_high, char c) => key = 4, prev_key_high = some_global_boolean, c = 'a'

这些变量中的每一个都有一个局部范围，并且它具有与您在调用中使用的参数/变量/值相同的值，但该变量在内存中的位置完全不同。

现在，有不同的方法来处理这个问题，我个人不鼓励人们使用全局变量：

1.在你的主函数中实例化一个变量（你想要的静态或动态），并使用指向该特定变量的指针：

    int main(int argc, char const *argv[])
    {
       boolean some_global_boolean = true; //or false or w/e or initialize it as you wish
       check(4, &some_global_boolean, 'a');
       return 0;
    }

    boolean check(int key, boolean * prev_key_high, char c){

    if (key == LOW) {
        if ( *prev_key_high){
          *prev_key_high = false;
          Serial.println(c);
          return true;
        }
    }

    else {
        *prev_key_high = true;
        return false;
      }
    }

2.如果你坚持使用全局变量，直接使用，或者结合之前的注释使用。我鼓励您学习指针并使用它们。

boolean check(int key, char c){

    if (key == LOW) {
        if ( some_global_boolean){
            some_global_boolean = false;
            Serial.println(c);
            return true;
        }
    }

    else{
          some_global_boolean = true;
          return false;
        }
    }
}
于 2013-09-19T20:20:10.403 回答