From: use_my_alias_here@hotmail.com   
      
   On 2011-07-06 20:19, Daniel Krügler wrote:   
   > Am 06.07.2011 01:03, schrieb DeMarcus:   
   >> Hi,   
   >>   
   >> Why doesn't this compile?   
   >>   
   >> class MyClass   
   >> {   
   >> public:   
   >> MyClass( int i ) : i_(i) { /* non-const ops */ }   
   >>   
   >> constexpr int f() const { return i_; }   
   >>   
   >> private:   
   >>   
   >> const int i_;   
   >> };   
   >>   
   >>   
   >> In gcc4.6.1 I get   
   >> error: enclosing class of ‘int MyClass::f() const’ is not a literal type   
   >>   
   >> To me f() only uses a constant, so what can go wrong?   
   >   
   > For a literal type it is irrelevant whether a member is constant or not,   
   > the problem with your type is, that there is no constexpr constructor   
   > that initializes the member i_. Interpreting your comment correctly,   
   > MyClass::MyClass(int i) could not be marked as constexpr constructor   
   > (because of further operations within the constructor body), but without   
   > this guarantee there is no way to possibly initialize an object of   
   > MyClass in a way that the aforementioned member.   
   >   
   > Test case:   
   >   
   > constexpr int i = MyClass(42).f();   
   >   
      
   Somehow I thought that the compiler would see that it's actually f()   
   that is used (which is constexpr) and that it uses a const int which   
   must have been initialized by the time it's used in f(). Therefore the   
   compiler could ignore that the constructor is non-constexpr. But I'm not   
   familiar with constexpr and I guess it's more complicated than that.   
      
   > In this example the sub expression MyClass(42) does not satisfy the   
   > criteria for a constant expression, therefore MyClass can never be part   
   > of a constant expression. Either   
   >   
   > a) remove the constexpr from MyClass::f(), or   
   >   
   > b) make MyClass::f() a constexpr *static* member function returning the   
   > result of some constant expression (e.g. it could return the value of a   
   > static member that can be used in constant expressions), or   
   >   
   > c) provide another constexpr constructor for MyClass that initializes   
   > the member i_.   
   >   
      
   I was just so keen on the following but I guess I can forget it.   
      
   class MyClass   
   {   
   public:   
      MyClass( int id, const std::string& name )   
         : id_(id), name_(name) { /* non-const ops */ }   
      
      // Conversion operator to be used in switch.   
      constexpr operator int() const { return id_; }   
      
      std::string getName() const { return name_; }   
      
   private:   
      const int id_;   
      const std::string name_;   
   };   
      
   const MyClass FLYING_CAR( 42, "Flying car" );   
   const MyClass DRINKIN_BOAT( 4711, "Drinking boat" );   
      
   int main()   
   {   
      int i = randomVehicle();   
      
      switch( i )   
      {   
         case FLYING_CAR:   
            std::cout << "Lycky you!" << std::endl;   
            break;   
      
         case DRINKING_BOAT:   
            std::cout << "Bon voyage!" << std::endl;   
            break;   
      
         default:   
            std::cout << "Mi casa es tu casa!" << std::endl;   
      }   
   }   
      
      
   --   
         [ See http://www.gotw.ca/resources/clcm.htm for info about ]   
         [ comp.lang.c++.moderated.    First time posters: Do this! ]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)