Вот в МСДН обнаружил такую запись:

// C2062.cpp
class A {
   public:
      int i;   // ok
   protected:
      int j;   // ok
   private:
      int k;   // ok
   :
      int l;   // C2062
};

int main() {
}

отмечу, что являюсь не искушенным программером на С++ (во всяком случае я так думаю), но такое вижу первый раз. А на ошибку эту попал следующим образом, был такой код:

template<typename T>
class BlaBla : public T
{

};

typedef  BlaBla<int> IntBlaBla;

не помню каким макаром но получилось запараметризировать этот шаблон интом, вот и вылетела ошибка. По ходу пьесы хотелось бы знать, почему собственно запрещено наследоваться от встроенных типов, а поле структуры делать интом можно, физически это ведь тоже самое ( не функционально конечно, с точки зрения физической структуры данных).

Здравствуйте, Аноним, Вы писали:

А> По ходу пьесы хотелось бы знать, почему собственно запрещено наследоваться от встроенных типов,

Хотелось бы знать — как вы себе это представляете? Как обратиться к значению унаследованного int? Если очень надо, то можно так:

template <typename T>
class BaseTypeEncaps { T base; };

template <typename T>
class BlaBla : public BaseTypeEncaps<T> { ... };

и обращаться к членам базового класса через base.

Здравствуйте, Ivan Korotkov, Вы писали:

IK>Здравствуйте, Аноним, Вы писали:

А>> По ходу пьесы хотелось бы знать, почему собственно запрещено наследоваться от встроенных типов,

IK>Хотелось бы знать — как вы себе это представляете? Как обратиться к значению унаследованного int? Если очень надо, то можно так:

IK>template <typename T>
IK>class BaseTypeEncaps { T base; };

IK>template <typename T>
IK>class BlaBla : public BaseTypeEncaps<T> { ... };

IK>и обращаться к членам базового класса через base.

а кто мешает делать так:

struct BlaBla : public int
{
    void F1()
    {
       ((int&)*this) = 10;
    }
};

другое дело что это запрещено стандартом, но будь на месте инта любой другой пользовательский тип то все бы было естественно.

Здравствуйте, Аноним, Вы писали:

А>Вот в МСДН обнаружил такую запись:


А>

А>// C2062.cpp
А>class A {
А>   public:
А>      int i;   // ok
А>   protected:
А>      int j;   // ok
А>   private:
А>      int k;   // ok
А>   :
А>      int l;   // C2062
А>};

А>int main() {
А>}
А>

А>отмечу, что являюсь не искушенным программером на С++ (во всяком случае я так думаю), но такое вижу первый раз. А на ошибку эту попал следующим образом, был такой код:


А>

А>template<typename T>
А>class BlaBla : public T
А>{

А>};

А>typedef  BlaBla<int> IntBlaBla;
А>

А>не помню каким макаром но получилось запараметризировать этот шаблон интом, вот и вылетела ошибка. По ходу пьесы хотелось бы знать, почему собственно запрещено наследоваться от встроенных типов, а поле структуры делать интом можно, физически это ведь тоже самое ( не функционально конечно, с точки зрения физической структуры данных).

Смотреть здесь

Автор: adontz
Дата: 16.12.03

.

Здравствуйте, _nn_, Вы писали:

и все таки, пофиг наследование от простых типов, что бы значила запись, описанная в МСДН как обьяснение к ошибке компиляции:

// C2062.cpp
class A {
   public:
      int i;   // ok
   protected:
      int j;   // ok
   private:
      int k;   // ok
   : //What is it???
      int l;   // C2062
};

Мне просто интересно, что может значить такая конструкция вообще...

А>Мне просто интересно, что может значить такая конструкция вообще...

По ошибке поставлено двоеточие, компилятор выдает C2062 и пример это иллюстрирует.

Здравствуйте, <Аноним>, Вы писали:

А>

А>// C2062.cpp
А>   : //What is it???
А>

А>Мне просто интересно, что может значить такая конструкция вообще...

Да просто очепятка! И соответствующая реакция на нее компилятора