Exécuter une fois (une fois) dans une boucle éternelle ou une boucle vide?

Dec 12 2020

Je veux créer une syntaxe d'exécution une fois ou une fois dans la boucle pour toujours (boucle vide) pour tous les langages de programme.

Ce que j'ai trouvé la solution est de faire une nouvelle variable booléenne "exécutée" et définie sur true après exécution.

Ce n'est pas grave, mais que faire si je veux exécuter une fois une autre syntaxe? Dois-je à nouveau créer une nouvelle variable booléenne? Cela ne sera pas efficace. Imaginez qu'il y ait beaucoup de syntaxe, mais je dois créer une nouvelle exécutiine booléenne pour chaque syntaxe.

La solution est la fonction je pense

Par exemple

void loop()
{
lcd.print("OK");
}

CECI EST IMPRIMÉ POUR TOUJOURS Je souhaite qu'il fonctionne comme ça

void loop()
{
once(lcd.print("OK"));
}

donc "une fois" est une fonction avec une chaîne de paramètres qui est pour la commande / la syntaxe.

une fois ("commande")

Réponses

1 Paul Dec 12 2020 at 13:28

Plusieurs façons d'aborder cela

Voici une manière très courante de faire une telle opération. Comme vous l'avez déjà suggéré, avec un booléen global :

bool once = true; // global variable
void loop() {
  if (once) { // being called only once
    lcd.print("OK");
    once = false;
  }
}

Ne faites quelque chose qu'une seule fois après un moment précis :

void loop() {
  // millis() is the time in milliseconds after the startup 
  //if you want to print something once after a specific amount of time
  //this also includes a little "wait time" of 100 milliseconds as the statement might be asked with a delay
  if (mills() >= 1000 && mills() <= 1100) {// time in milliseconds
    lcd.print("OK");
  }
}

Et grâce à ce fil, avec la sortie de la boucle (ce n'est peut-être pas ce que vous recherchez):

void loop() {
  lcd.print("OK");
  exit(0);  //The 0 is required to prevent compile error.
}

Mais je suppose que vous essayez de créer une sorte d'interface, où une réponse spécifique est imprimée en ce qui concerne l'entrée de l'utilisateur (probablement de nombreuses possibilités)?! Dans ce cas, cela dépend en quelque sorte des entrées que vous obtenez:

En cas d' entiers :

void loop() {
  switch (input) { //input must be an integer
    case 0:
      lcd.print("OK"); //prints "ok" if input is 0
    case 1:
      lcd.print("Hello"); //prints "Hello" if input is 1
  }
}

Dans le cas de Stings / chars , vous devez aller avec une "if loop" à travers toutes les entrées possibles (ou avec un tableau de Strings / chars):

void loop() {
  lcd.print("Turn off?"); //asks if it should do something
  if (input == "yes") { //String input
    lcd.print("OK, shut down!");
    //do something
  }
  else if (input == 'n' || input == 'N') { //char input
    lcd.print("OK, no shut down!");
    //do something
  }
}

Une fonction que vous recherchez, où une réponse spécifique ne s'imprime qu'UNE SEULE FOIS concernant une entrée, peut être simplement archivée par des boucles if / else . Si une chaîne ne doit être imprimée qu'une seule fois au démarrage, imprimez-la dans le constructeur "setup ()". Sinon, avec les booléens globaux, quelque chose comme ça est possible.

Notez que ce ne sont que mes suggestions basées sur mon expérience, mais cela ne signifie pas nécessairement que d'autres solutions ne sont pas disponibles. J'espère que cela aide encore :)

1 AyxanHaqverdili Dec 12 2020 at 13:12

Voici une façon de le faire:

void loop()
{
    { // execute once. Can put this in a separate function also
        static bool executed = (lcd.print("OK"), true);
    }
}

Vous êtes assuré que cette variable est initialisée une fois.

Si vous voulez la oncesyntaxe de votre question, vous pouvez obtenir quelque chose de similaire avec une macro:

#define ONCE(...) \
{\
 static bool executed = ([&]{__VA_ARGS__;}(), true); \
}


void loop()
{
    ONCE(lcd.print("OK"))
}
1 Jarod42 Dec 12 2020 at 15:32

En C ++, il y a std::call_oncece qui est même multi_thread, alors vous pouvez le faire de manière générique:

template <typename F>
void simple_do_once(F f)
{
    static std::once_flag flag;
    std::call_once(flag, f);
}

Comme lambda a un type unique, vous avez un indicateur par lambda:

Démo