enum class η κάτι άλλο

[void90]

Έχω μια συνάρτηση void function(param1 c)
Το c είναι ακέραιος και συμβολίζει το χρώμα, που μπορεί να είναι κόκκινο, πράσινο, μπλε.

Έκανα το εξής:

enum Color {Red = 2, Green = 4 , Blue = 8};
.
.
.
void function(Color c)
{
	.
	.
	.
}

Αλλά είδα οτι αυτά

function(2);
int x = 1;
function(x);
//κλπ

είναι αποδεκτά.

Εγώ θέλω να είναι αποδεκτές μόνο εντολές του στυλ

function(Color::Red); //κλπ

Οπότε δοκίμασα αυτό:

enum class Color: int {Red = 2, Green = 4 , Blue = 8};

Αλλά έτσι υπάρχει πρόβλημα όταν θέλω συνδιασμούς χρωμάτων.
Δηλαδή το παρακάτω δεν γίνεται αποδεκτό

function(Color::Red | Color::Green);

Μια λύση είναι να κάνω έναν operator| για το Color αλλά μου φαίνεται κάπως άσχημο
Υπάρχει άλλη καλύτερη λύση;

[axxis]

Δεν νομίζω ότι μπορείς να κάνεις κάτι γι'αυτό.
Γιατί εφόσον θέλεις να επιτρέπεις και συνδυασμούς χρωμάτων, τελικά δεν θέλεις να περιορίσεις την παράμετρο στις τιμές του enum.
Εγώ θα πήγαινα με την πρώτη λύση και αν θέλεις μπορείς να βάλεις κάποιον έλεγχο στην αρχή της function ώστε να μην συνεχίζει αν δεν είναι αποδεκτές οι τιμές της παραμέτρου.
Θα μπορούσες να πας και με τη δεύτερη λύση σου και να ορίσεις εκτός των Red, Green, Blue και τους συνδυασμούς τους, RedGreen, RedBlue, GreenBlue, RedGreenBlue και ο operator | να φτιάχνει τον αντίστοιχο συνδυασμό αλλά για μένα είναι πιο απλό το πρώτο.

[tsigarid]

Μπορείς να φτιάξεις μια enum με όνομα "singleColor" ή κάτι τέτοιο και να έχεις μια δεύτερη function που θα επιτρέπει πιο χαλαρούς κανόνες (άρα και συνδυασμούς) η οποία θα καλεί για κάθε ένα χρώμα την βασική.

[Παπι]

classes... classes...

#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>

class Color
{
	unsigned int val;
public:
	static const Color Red;
	static const Color Blue;
	static const Color Green;
	static const Color Purple;
public:
	Color(): val(0)
	{
	}
	Color(unsigned int color): val(color)
	{
	
	}
	Color operator +(const Color& color) const;
	
	const std::string ToString() const;
	const std::string ToFriendlyName() const;
};
Color Color::operator +(const Color& color) const
{
	//edw 8es na psakseis gia kanoniko algorthmo poy pros8etei xrwmata.
	return Color( val | color.val );

}
const std::string Color::ToString() const
{
	std::stringstream ss;
	ss<<std::hex<<val;
	return ss.str();
}
const std::string Color::ToFriendlyName() const
{
	switch (val)
	{
	case 0x00ff0000: return "Red";
	case 0x000000ff: return "Blue";
	case 0x0000ff00: return "Green";
	case 0x00ff00ff: return "Purple";
	default:
		return "Undefined";
	}
}

const Color Color::Red = Color(0x00ff0000);
const Color Color::Blue = Color(0x000000ff);
const Color Color::Green = Color(0x0000ff00);
const Color Color::Purple = Color(0x00ff00ff);


#define PRINT_EXPR_AND_RESULT(expr) std::cout<<"Expr: "<<#expr<<"\nResult:"<<(expr)<<std::endl<<std::endl

int main()
{
	Color test;
	PRINT_EXPR_AND_RESULT(test.ToFriendlyName());

	PRINT_EXPR_AND_RESULT(
		(test = Color::Red).ToFriendlyName()
		);
	PRINT_EXPR_AND_RESULT(
		(Color::Red + Color::Blue).ToFriendlyName()
		);
	PRINT_EXPR_AND_RESULT(
		(Color::Red + Color::Green).ToFriendlyName()
		);
	return 0;
}

output

Expr: test.ToFriendlyName()
Result:Undefined

Expr: (test = Color::Red).ToFriendlyName()
Result:Red

Expr: (Color::Red + Color::Blue).ToFriendlyName()
Result:Purple

Expr: (Color::Red + Color::Green).ToFriendlyName()
Result:Undefined

[Xerion]

Αν έχεις compiler που να υποστηρίζει C++11 και πιο συγκεκριμένα strongly typed enums τότε μπορείς να κάνεις αυτό που θες μιας και δεν θα έχεις implicit conversion σε int.

[AlbNik]

Αν έχεις compiler που να υποστηρίζει C++11 και πιο συγκεκριμένα strongly typed enums τότε μπορείς να κάνεις αυτό που θες μιας και δεν θα έχεις implicit conversion σε int.

Αυτο δεν μπορεις να το αποφύγεις ουτε σε C# (δεν ξερω για C++11)

function(Color.Red +1234);

[void90]

Αν έχεις compiler που να υποστηρίζει C++11 και πιο συγκεκριμένα strongly typed enums τότε μπορείς να κάνεις αυτό που θες μιας και δεν θα έχεις implicit conversion σε int.

Μάλλον δεν το διάβασες όλο, ή δεν κατάλαβα τι λες. Ήδη δοκίμασα να το κάνω με enum class αλλά δεν βόλευε γιατί με enum class δεν μπορείς να κάνεις function(Color::Red | Color::Green);

Η λύση από Παπι μου άρεσε

[Xerion]

Σκεφτόμουνα κατί σαν

// Αν δεν θες Hex εννοέιτε οτι τα κάνεις int
enum class Color
{
  Red    = 0xff0000,  // 2
  Green  = 0x00ff00,  // 4
  Blue   = 0x0000ff,  // 8
  Purple = 0x00ff00ff // 6
};

std::ostream& operator << (std::ostream& os, const Color& c)
{
  switch (c)
  {
    case Color::Red:    os << "Red"; break;
    case Color::Green:  os << "Blue"; break;
    case Color::Blue:   os << "Green"; break;
    case Color::Purple: os << "Purple"; break;
    default:
      os << "Undefined"; break;
  }

  return os;
}

inline Color operator | (const Color& l, const Color& r)
{
  return static_cast<Color>(static_cast<int>(l) | static_cast<int>(r));
}

// Σε περίπτωση που προτιμάς operator+ αντι για operator|
inline Color operator + (const Color& l, const Color& r)
{
  return static_cast<Color>(static_cast<int>(l) | static_cast<int>(r));
}

void foo(Color val)
{
  std::cout << val << std::endl;
}

int main()
{
  foo(1); // Error
  int x = 1;
  foo(x); // Error
  foo(Color::Red); // OK
  foo(Color::Red | Color::Blue); // OK
  foo(Color::Red + Color::Blue); // OK
}