Определение собственных явных преобразований

Предположим, если преобразование из одного типа в другой тип недоступно посредством явного приведения, например static_cast, можно ли определить для него явные операторы преобразования?

Изменить:

Я ищу способ определить явные операторы преобразования для следующего:

class SmallInt {

public:

    // The Default Constructor
    SmallInt(int i = 0): val(i) {
        if (i < 0 || i > 255)
        throw std::out_of_range("Bad SmallInt initializer");
    }

    // Conversion Operator
    operator int() const {
        return val;
    }

private:
    std::size_t val;

};

int main()
{
     SmallInt si(100);

     int i = si; // here, I want an explicit conversion.
}

c++ type-conversion explicit
person Jason    schedule 31.08.2011    source источник
comment
Операторы явного преобразования были бы, ну, методами, которые возвращают целевой тип. Или я что-то упускаю?   -  person Amardeep AC9MF    schedule 31.08.2011

Ответы (3)


arrow_upward
3
arrow_downward

Для пользовательских типов можно определить оператор приведения типа . Синтаксис оператора такой

operator <return-type>()

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

Не уверен в этом, но я считаю, что С++ 0x позволяет вам указать приведение типа explicit для предотвращения неявных преобразований типов.

person Praetorian    schedule 31.08.2011
comment
@Toolbox, какие компиляторы реализовали эту функцию C++ 11? Я не думаю, что MSVC++ 2010 имеет. - person Seth Carnegie; 31.08.2011
comment
@Seth Carnegie Согласно gcc.gnu.org/projects/cxx0x.html, явно операторы преобразования доступны в GCC 4.5. Я не смог проверить это на себе. - person Dawson; 31.08.2011

arrow_upward
2
arrow_downward

В текущем стандарте преобразования из вашего типа в другой тип не могут быть помечены explicit, что до некоторой степени имеет смысл: если вы хотите явно преобразовать, вы всегда можете предоставить функцию, которая реализует преобразование:

struct small_int {
   int value();
};
small_int si(10);
int i = si.value();   // explicit in some sense, cannot be implicitly converted

С другой стороны, это может не иметь такого большого смысла, поскольку в будущем стандарте, если ваш компилятор его поддерживает, вы можете пометить оператор преобразования как explicit:

struct small_int {
   explicit operator int();
};
small_int si(10);
// int i = si;                 // error
int i = (int)si;               // ok: explicit conversion
int j = static_cast<int>(si);  // ok: explicit conversion
person David Rodríguez - dribeas    schedule 31.08.2011

arrow_upward
0
arrow_downward

Если это то, что вы хотите, вы можете определить операторы преобразования, например:

void foo (bool b) {}

struct S {
   operator bool () {return true;} // convert to a bool
};

int main () {
   S s;
   foo (s);  // call the operator bool.
}

Хотя на самом деле это не рекомендуется, потому что после определения такое неявное преобразование может произойти в неудобных местах, где вы этого не ожидаете.

person Nicolas Grebille    schedule 31.08.2011
comment
Да, но могу ли я превратить это в принятие только явных преобразований? - person Jason; 31.08.2011
comment
Я так думаю в С++ 0x, как сказано в ответе выше. Почему бы вам просто не определить функцию-член to_XXX? - person Nicolas Grebille; 31.08.2011