Enum als fuctieparameter

Hoi,

Weet hier iemand hoe je een enum als functieparameter kan gebruiken?

Ik zou een enum willen aanmaken

Vb enum kleur {rood, wit, groen} ;

En deze willen doorgeven naar een functie, zodat ik achteraf deze enums onder meerdere namen kan gebruiken.

Zoiets?

enum kleuren_t{rood, wit, groen};

void setup() {

}

void loop() {
  enumTest(rood);
}

void enumTest(kleuren_t k){
  //doe iets
}

rood is dus 0
wit 1 enz.
en ja je kunt ze dan overal gebruiken, alleen je kunt geen twee keer rood voor verschillende cijfers gebruiken. en het blijft een integer, dus wit ==1 is true.

Ben er ondertussen achter.

Je moet wel eerst een functieprototype maken, anders krijg je fouten bij het compileren.

enum kleuren_t{rood, wit, groen};

void enumTest(kleuren_t k);

void setup() {

}

void loop() {
enumTest(rood);
}

void enumTest(kleuren_t k){
//doe iets
}

Ligt denk ik weer een beetje aan de IDE versie. Wat ik liet zien werkte zonder problemen in (mijn goto versie) 1.8.5.

PS Graag de volgende keer code-tags gebruiken. Helaas past het forum geen syntax highlight toe maar code is dan een stuk makkelijker te kopiëren en andere BBCode kan geen roet in het eten gooien.

guitar: ditgaat echt niet kijk maar eens naar een voorbeeld van enum dan wel een functie.

In ‘C’ was een enum een #define, maar ik heb een tijdje geleden geleerd dat een enum in ‘C++’ een type is.
Toch is het niet zomaar hetzelfde als de anderen types, het blijft een beetje tegen de #define aanhangen.
Om dat probleem op te lossen en er een “echt” type van de maken is er de “enum class”.
Het onderste deel van deze pagina beschrijft de enum: Other data types - C++ Tutorials.

Ik heb eens geprobeerd wat de size van een enum is, die is twee, zowel voor de definitie als voor het object.
Ook kunnen de enum waarden in de switch-case gebruikt worden.

// Definieer het type.
// Dit is alleen het type, niet een object/variabele.
enum kleuren_t
{
  rood,
  wit,
  groen,
  zonnebloemgeel,
  hemelsblauw,
  RAL9010,
};

// Soms is prototyping nodig.
// void enumTest( kleuren_t k);

void setup()
{
  Serial.begin( 9600);

  kleuren_t myColor;
  Serial.print(  "sizeof( kleuren_t) = ");
  Serial.println( sizeof( kleuren_t));      // geeft 2, net als een int
  Serial.print(  "sizeof( myColor) = ");
  Serial.println( sizeof( myColor));        // geeft 2, net als een int

  myColor = rood;             // via een object van het type kleuren_t
  enumTest( myColor);

  enumTest( wit);           // meteen de kleur gebruiken, correct

  int i = zonnebloemgeel;
  enumTest( i);              // ander type, compiler geeft waarschuwing

  byte b = hemelsblauw;
  enumTest( b);              // ander type, compiler geeft waarschuwing

  int j = RAL9010;
  enumTest( (kleuren_t) j);  // goede conversie, correct

  int getal = 1000;
  enumTest( getal);          // ander type, compiler geeft waarschuwing
}

void loop()
{
}

void enumTest( kleuren_t k)
{
  Serial.print( k);
  Serial.print( ", ");

  if ( k == rood)
    Serial.print( "rood");
  else if ( k == wit)
    Serial.print( "wit");
  else if ( k == groen)
    Serial.print( "groen");
  else if ( k == zonnebloemgeel)
    Serial.print( "zonnebloemgeel");
  else if ( k == hemelsblauw)
    Serial.print( "hemelsblauw");
  else if ( k == RAL9010)
    Serial.print( "RAL9010");
  else
    Serial.print( "?");

  Serial.print( ", ");

  switch ( k)
  {
    case rood:
      Serial.print( "rood");
      break;
    case wit:
      Serial.print( "wit");
      break;
    case groen:
      Serial.print( "groen");
      break;
    case zonnebloemgeel:
      Serial.print( "zonnebloemgeel");
      break;
    case hemelsblauw:
      Serial.print( "hemelsblauw");
      break;
    case RAL9010:
      Serial.print( "RAL9010");
      break;
    default:
      Serial.print( "?");
      break;
  }
  Serial.println();
}

Dat is dus heel compatible met de oude manier waarop het een #define was.

De Arduino pre-processor gaat soms de mist in en dan is functie-prototyping nodig. Vooral als de code over meerdere tabbladen is verdeeld.

Je kan inderdaad je enum ok als type gebruiken. Maar je hebt dan nog wel een warning:

sketch_aug20a.ino:49:6: note: initializing argument 1 of 'void enumTest(kleuren_t)'

 void enumTest( kleuren_t k)

      ^

En daarvan weet ik ook even niet wat daar aan te doen...

En vaak vind ik het jammer dat je er dan niet makkelijk meer over heen kunt loopen. Dit omdat een enum niet aaneengesloten hoeft te zijn. Vandaar dat ik vaak wel enums gebruik om menselijke namen te geven maar ze gebruik als een int.

Die foutmelding komt er alleen bij als ik een verkeerd type als parameter mee geef.
Maak maar commentaar van de drie aanroepen met 'int' en 'byte', dan is ook die waarschuwing verdwenen.

Ow, grappig. Omdat het de definitie aan duid als error locatie had ik niet verwacht dat het te maken zou hebben met het gebruik van de functie :o