Re[2]: перегрузка методов - C/C++

Уважаемые, подскажите пожайлуста по такому вопросу,
хотел бы реализовать метод который бы в зависимости от входного параметра
(ну и дополнительной логики в нутри класса),
возвращал бы разные типы данных..

BOOL Class::GetValue(LPCTSTR lp)
{
...
return TRUE;
}

int Class::GetValue(LPCTSTR lp)
{
int n;
...
...
return n;
}

LPCTSTR Class::GetValue(LPCTSTR lp)
{
...
return lp;
}
и т.д......

Я так понял что перегружать метод таким образом нельзя,
(т.е обязательно необходимы разные типы или колличество входящих параметров)
поскажите плс. возможные способы решения.
Спасибо!

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

S>Уважаемые, подскажите пожайлуста по такому вопросу,
S>хотел бы реализовать метод который бы в зависимости от входного параметра
S>(ну и дополнительной логики в нутри класса),
S>возвращал бы разные типы данных..

S>BOOL Class::GetValue(LPCTSTR lp)
S>{
S> ...
S> return TRUE;
S>}

S>int Class::GetValue(LPCTSTR lp)
S>{
S> int n;
S> ...
S> ...
S> return n;
S>}

S>LPCTSTR Class::GetValue(LPCTSTR lp)
S>{
S> ...
S> return lp;
S>}
S>и т.д......

S>Я так понял что перегружать метод таким образом нельзя,
S>(т.е обязательно необходимы разные типы или колличество входящих параметров)
S>поскажите плс. возможные способы решения.
S>Спасибо!

Скажи честно так ли это небходимо чтобы методы назывались одинаково GetValue
Это что жизненно важно
Может не мучаться и назвать их по разному GetValueB GetValueI ...

Ну нельзя компилятор убедить в этом (возвращаемое значение не влияет на перегрузку)
и сколько бы ты его в этом не убеждал он не согласится

Здравствуйте, Какая разница, Вы писали:

КР>Здравствуйте, solearis, Вы писали:

S>>Уважаемые, подскажите пожайлуста по такому вопросу,
S>>хотел бы реализовать метод который бы в зависимости от входного параметра
S>>(ну и дополнительной логики в нутри класса),
S>>возвращал бы разные типы данных..

S>>BOOL Class::GetValue(LPCTSTR lp)
S>>{
S>> ...
S>> return TRUE;
S>>}

S>>int Class::GetValue(LPCTSTR lp)
S>>{
S>> int n;
S>> ...
S>> ...
S>> return n;
S>>}

S>>LPCTSTR Class::GetValue(LPCTSTR lp)
S>>{
S>> ...
S>> return lp;
S>>}
S>>и т.д......

S>>Я так понял что перегружать метод таким образом нельзя,
S>>(т.е обязательно необходимы разные типы или колличество входящих параметров)
S>>поскажите плс. возможные способы решения.
S>>Спасибо!

КР>Скажи честно так ли это небходимо чтобы методы назывались одинаково GetValue
КР>Это что жизненно важно
КР>Может не мучаться и назвать их по разному GetValueB GetValueI ...

КР>Ну нельзя компилятор убедить в этом (возвращаемое значение не влияет на перегрузку)
КР>и сколько бы ты его в этом не убеждал он не согласится

Нет, одинаковые названия для методов не критичны, но как мне кажется так было бы "красивее",
возможно так и реализую (GetValueB GetValueI), но интересны все варианты..
Может с помощью шаблонов както можно решить такую задачу?

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

S>Уважаемые, подскажите пожайлуста по такому вопросу,
S>хотел бы реализовать метод который бы в зависимости от входного параметра
S>(ну и дополнительной логики в нутри класса),
S>возвращал бы разные типы данных..

S>BOOL Class::GetValue(LPCTSTR lp)
S>{
S> ...
S> return TRUE;
S>}

S>int Class::GetValue(LPCTSTR lp)
S>{
S> int n;
S> ...
S> ...
S> return n;
S>}

S>LPCTSTR Class::GetValue(LPCTSTR lp)
S>{
S> ...
S> return lp;
S>}
S>и т.д......

S>Я так понял что перегружать метод таким образом нельзя,
S>(т.е обязательно необходимы разные типы или колличество входящих параметров)
S>поскажите плс. возможные способы решения.
S>Спасибо!

Способ решения взят из книги modern c++ design

template <typename T>
struct Type2Type
{
    typedef T OriginalType;
};

class some
{
public:
    int do_some(some & other, Type2Type<int>)
    {
        return 0;
    }

    float do_some(some & other, Type2Type<float>)
    {
        return 0.0;
    }

        // или шаблон
    template <typename ResultType>
    ResultType do_some(some & other, Type2Type<ResultType>)
    {
        return T();
    }
};

void fn_test()
{
    some obj, obj2;
    float f= obj.do_some(obj2, Type2Type<float>() );
}

Перегрузка методов не должна отличаться только по типу результата.

т.е. везде добавляем ещё один параметр Type2Type<ResultType>

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

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

S>>Уважаемые, подскажите пожайлуста по такому вопросу,
S>>хотел бы реализовать метод который бы в зависимости от входного параметра
S>>(ну и дополнительной логики в нутри класса),
S>>возвращал бы разные типы данных..

S>>BOOL Class::GetValue(LPCTSTR lp)
S>>{
S>> ...
S>> return TRUE;
S>>}

S>>int Class::GetValue(LPCTSTR lp)
S>>{
S>> int n;
S>> ...
S>> ...
S>> return n;
S>>}

S>>LPCTSTR Class::GetValue(LPCTSTR lp)
S>>{
S>> ...
S>> return lp;
S>>}
S>>и т.д......

S>>Я так понял что перегружать метод таким образом нельзя,
S>>(т.е обязательно необходимы разные типы или колличество входящих параметров)
S>>поскажите плс. возможные способы решения.
S>>Спасибо!

S>Способ решения взят из книги modern c++ design

S>

S>template <typename T>
S>struct Type2Type
S>{
S>    typedef T OriginalType;
S>};

S>class some
S>{
S>public:
S>    int do_some(some & other, Type2Type<int>)
S>    {
S>        return 0;
S>    }

S>    float do_some(some & other, Type2Type<float>)
S>    {
S>        return 0.0;
S>    }

S>        // или шаблон
S>    template <typename ResultType>
S>    ResultType do_some(some & other, Type2Type<ResultType>)
S>    {
S>        return T();
S>    }
S>};

S>void fn_test()
S>{
S>    some obj, obj2;
S>    float f= obj.do_some(obj2, Type2Type<float>() );
S>}
S>

S>Перегрузка методов не должна отличаться только по типу результата.

S>т.е. везде добавляем ещё один параметр Type2Type<ResultType>

ага... спасибо! , сейчас попробую..

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

S>Здравствуйте, Какая разница, Вы писали:

КР>>Скажи честно так ли это небходимо чтобы методы назывались одинаково GetValue
КР>>Это что жизненно важно
КР>>Может не мучаться и назвать их по разному GetValueB GetValueI ...

КР>>Ну нельзя компилятор убедить в этом (возвращаемое значение не влияет на перегрузку)
КР>>и сколько бы ты его в этом не убеждал он не согласится

S>Нет, одинаковые названия для методов не критичны, но как мне кажется так было бы "красивее",
S>возможно так и реализую (GetValueB GetValueI), но интересны все варианты..
S>Может с помощью шаблонов както можно решить такую задачу?

Можно решить

здесь

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

С точки зрения академического пример полезный

Но с точки зрения практического Мы добились только одного — нагрузки на пальцы при набивании кода

вместо

float f = obj.do_someF(obj2);

надо бить так

float f= obj.do_some(obj2, Type2Type<float>() );

Но если автор топика хочет поработать ручками то welcome

Здравствуйте, Какая разница, Вы писали:

КР>Здравствуйте, Sm0ke, Вы писали:

КР>С точки зрения академического пример полезный

КР>Но с точки зрения практического Мы добились только одного — нагрузки на пальцы при набивании кода

КР>вместо

КР>

КР>float f = obj.do_someF(obj2);
КР>

КР>надо бить так

КР>

КР>float f= obj.do_some(obj2, Type2Type<float>() );
КР>

КР>Но если автор топика хочет поработать ручками то welcome

А если метод -- шаблон, то имена должны быть одинаковые.

Если это будет использоваться например внутри шаблонного класса
и не более чем в двух-трёх местах то неудобство не заметно.

Другое дело, что в качестве шаблонного параметра можно передавать типы или integral константы компилятора.
Имена методов (идентификаторы) передавать нельзя (правда можно указатели на методы).

Так что всё зависит от задачи...

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

На самом деле, можно исхитриться — делать функции, различающиеся возвращаемым значением... вот так

class Class
{
    friend class Class::PostponedType;
    int     GetIntValue(LPCTSTR);
    LPCTSTR GetStrValue(LPCTSTR);
public:
    class PostponedType
    {
        // связанные переменные
        Class* host;
        LPCTSTR arg;
        
        friend class Class;
        PostponedType(Class* p, LPCTSTR a) : host(p), arg(a) {}
    public:
        operator int()     { host->GetIntValue(arg); }
        operator LPCTSTR() { host->GetStrValue(arg); }
    };
    PostponedType GetValue(LPCTSTR arg) { return PostponedType(this,arg); }
    .....
};

int main()
{
    Class c;
    int x = c.GetValue(_T("aaa"));
    LPCTSTR s = c.GetValue(_T("bbb"));
}

Всякие красивости с перегрузкой и шаблонами — добавьте по вкусу.
У этого способа есть ограничения, связанные с двойным неявным приведением.

void foo(CString);
template<class T> void bar(T);

int main()
{
    Class c;

    // Неявное приведение PostponedType к CString напрямую отсутствует. Нужно через int или через LPCTSTR? Ошибка компиляции.
    CString s = c.GetValue(_T("bbb"));
    foo(c.GetValue(_T("bbb"));
    // нужно писать
    CString s = (LPCTSTR)c.GetValue(_T("bbb"));
    foo((LPCTSTR)c.GetValue(_T("bbb"));
    
    // Конкретизация шаблона. Может привести к смысловым ошибкам.
    bar(c.GetValue(_T("bbb")); // T = PostponedType, а не int или LPCTSTR
}

... << RSDN@Home 1.2.0 alpha rev. 655>>

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

...

S>Я так понял что перегружать метод таким образом нельзя,
S>(т.е обязательно необходимы разные типы или колличество входящих параметров)
S>поскажите плс. возможные способы решения.
S>Спасибо!

Шаблонный метод.

class some
{
public:
    template <class T>
    T do_some();

    template <>
    int do_some<int>()
    {
        return 0;
    }

    template <>
    float do_some<float>()
    {
        return 0.0;
    }
};

    // определение вовне класса
template <>
void some::do_some<void>()
{
}

void fn_test()
{
    some obj;
    float f= obj.do_some<float>();
}

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

S>Шаблонный метод.

Вот только не надо смешивать. Шаблон метода супротив паттерна "Шаблонный метод".

... << RSDN@Home 1.2.0 alpha rev. 655>>

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

К>На самом деле, можно исхитриться — делать функции, различающиеся возвращаемым значением... вот так

Глядя на этот код и количество проблем с ним связанных, проще вообще от этой идеи отказаться;

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

N>Здравствуйте, Кодт, Вы писали:

К>>На самом деле, можно исхитриться — делать функции, различающиеся возвращаемым значением... вот так

N>Глядя на этот код и количество проблем с ним связанных, проще вообще от этой идеи отказаться;

Цитата не-помню-кого:

Глядя на эту документацию по си++ и количество проблем с ним связанных, проще вообще от этого языка отказаться;

Такое можно сказать и о жизни в целом...
Но может лучше не сказать?

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

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

S>>Шаблонный метод.

К>Вот только не надо смешивать. Шаблон метода супротив паттерна "Шаблонный метод".

Так случайно получилось

ambiguity однако.

Имолось виду не шаблонный класс, а шаблонный метод.
Всмысле метод-шаблон.

Короче не путайте меня... , я сам

	От:	solearis
	Дата:	03.11.06 08:41
	Оценка:

	От:	Какая разница
	Дата:	03.11.06 08:58
	Оценка:	+1

	От:	solearis
	Дата:	03.11.06 09:03
	Оценка:

От:	Sm0ke	ksi
Дата:	03.11.06 09:05
Оценка:

	От:	solearis
	Дата:	03.11.06 09:08
	Оценка: