Всем привет

Есть некий довольно большой шаблон класса.
У него есть некая переменная

T m_value;

в процессе проектирования выяснилось, что нужна некая функция

void SetValue(String strValue);

реализация которой упирается в T, например int atoi, float atof в простых случаях, ну и так далее. String тут некий чужой строковый класс, умеющий возвращать char*.

как бы сделать реализацию этой функции для разных T попроще? Пока вижу только отказ от шаблона и создание классов вручную для каждого типа с одной этой функцией.
Вроде можно было как-то конкретизировать отдельные вещи в шаблонах для определённых типов?

среда MSVS 2010

_{когда-то давно выходил из положения путём создания строкового класса, который умел кастоваться во все нужные типы, но как-то это не очень...}

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

CEM>в процессе проектирования выяснилось, что нужна некая функция

CEM>

CEM>void SetValue(String strValue);
CEM>

CEM>реализация которой упирается в T, например int atoi, float atof в простых случаях, ну и так далее. String тут некий чужой строковый класс, умеющий возвращать char*.

CEM>как бы сделать реализацию этой функции для разных T попроще? Пока вижу только отказ от шаблона и создание классов вручную для каждого типа с одной этой функцией.
CEM>Вроде можно было как-то конкретизировать отдельные вещи в шаблонах для определённых типов?

m_value = boost::lexical_cast<T>(strValue);

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

CEM>Всем привет
CEM>_{когда-то давно выходил из положения путём создания строкового класса, который умел кастоваться во все нужные типы, но как-то это не очень...}

А зачем для этого вообще лишние такие сущности архитектуры как классы? Чем не устраивает

bool str_to_value(int32_t &result, const String &str);
bool str_to_value(int64_t &result, const String &str);
...
bool str_to_value(float   &result, const String &str);
bool str_to_value(double  &result, const String &str);
...

?

Или более универсальнее

bool str_to_value(int32_t &result, const char *str);
bool str_to_value(int64_t &result, const char *str);
...
bool str_to_value(float   &result, const char *str);
bool str_to_value(double  &result, const char *str);
...

И вообще как уже тут советовали, для таких целей надо что-то использовать готовое, чтобы не раздувать код юнит-тестов

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

Z>

Z>m_value = boost::lexical_cast<T>(strValue);
Z>

буст всегда приходит на помощь, когда про него забываешь

но я его (наверно) не смогу заиспользовать, так как Т у меня могут быть классы из чужой большой библиотеки.
Но я всё равно попробую.

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

AD>А зачем для этого вообще лишние такие сущности архитектуры как классы? Чем не устраивает
AD>?

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

AD>Или более универсальнее
AD>

AD>bool str_to_value(int32_t &result, const char *str);
AD>bool str_to_value(int64_t &result, const char *str);
AD>...
AD>bool str_to_value(float   &result, const char *str);
AD>bool str_to_value(double  &result, const char *str);
AD>...
AD>

ну и тут опять напрашивается шаблон функции

AD>И вообще как уже тут советовали, для таких целей надо что-то использовать готовое, чтобы не раздувать код юнит-тестов

+1, но, эх, не пишу я юнит-тесты

В общем, можно сделать так:

//    Temple.h
template<class T> class CTemple
{
    T    m_value;
public:
    CTemple(void);
public:
    ~CTemple(void);

    void SetValue(char *pszValue);
};


template<class T> CTemple<T>::CTemple(void)
{
}

template<class T> CTemple<T>::~CTemple(void)
{
}
//    общий случай, когда Т знает, как кастовать в себя строку
template<class T> void CTemple<T>::SetValue(char *pszValue)
{
    m_value = (T)pszValue;
}

//    Temple.cpp
#include <Stdlib.h>
#include "Temple.h"
#include<string>

//    2 частных случая, int и double
template<> void CTemple<int>::SetValue(char *pszValue)
{
    m_value = atoi(pszValue);
}
template<> void CTemple<double>::SetValue(char *pszValue)
{
    m_value = atof(pszValue);
}

//    once in code
void foo()
{
    CTemple<std::string> tStr;
    CTemple<int> tInt;
    CTemple<double> tDouble;
//...
    tStr.SetValue("123");
    tInt.SetValue("123");
    tDouble.SetValue("123");
// все три вызова идут в разные функции
}

Здравствуйте, CEMb, Вы писали:
CEM>Кроме того, в данном случае класс(строковый) — чёрная коробка, которая сама обо всём позаботится, не нужно писать кучу функций в глобальном скопе.
Вот это "обо всём" настораживает. Всё — это понятие ёмкое, туда можно воткнуть всё что угодно, что приведёт к монструозному классу строки.

CEM>ну и тут опять напрашивается шаблон функции
Зачем шаблон функции? Просто функции безо всяких шаблонов. Не надо плодить сущности без необходимости.

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

CEM>>Кроме того, в данном случае класс(строковый) — чёрная коробка, которая сама обо всём позаботится, не нужно писать кучу функций в глобальном скопе.
AD>Вот это "обо всём" настораживает. Всё — это понятие ёмкое, туда можно воткнуть всё что угодно, что приведёт к монструозному классу строки.

CEM>>ну и тут опять напрашивается шаблон функции
AD>Зачем шаблон функции? Просто функции безо всяких шаблонов. Не надо плодить сущности без необходимости.

Не, ну, подразумевалось, всё нужное для каста из строки в используемые типы.
И класс строки один, а функций много (в классе их столько же, но они внутри класса). Плюс класс может быть и контейнером для строки и проверялкой валидности. В принципе, и так и так получается почти одинаково, просто для меня удобнее, когда оно классом/неймспейсом логически отделено от остального кода.

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

Похоже, вы изобретаете boots:variant