VPF::stringstream в map . Как? - Форум программистов

boostcoder

Дата 23.11.2011, 14:17 (ссылка)

(голосов:1)

Загрузка ...

pattern`щик

Профиль
Группа: Завсегдатай
Сообщений: 5458
Регистрация: 1.4.2010

Репутация: 49
Всего: 110

Цитата(RinOSpro @ 23.11.2011, 13:31

)

error: deleted function 'std::unique_ptr<_Tp, _Tp_Deleter>

чтоб много не думать, используй shared_ptr<>.

по поводу ключей: приведи все возможные.

--------------------

компилятор онлайн с поддержкой C++11
сборки компиляторов MinGW

bsa

Дата 23.11.2011, 14:27 (ссылка)

(нет голосов)

Загрузка ...

Эксперт

Профиль
Группа: Модератор
Сообщений: 9185
Регистрация: 6.4.2006
Где: Москва, Россия

Репутация: 63
Всего: 196

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

--------------------

Правильно заданный вопрос - половина ответа
Отзывы о работе модератора.

RinOSpro

Дата 23.11.2011, 14:45 (ссылка)

(голосов: 0)

Загрузка ...

Unregistered

Цитата(boostcoder @ 23.11.2011, 14:17

)

по поводу ключей: приведи все возможные.

написаны латиницей маленькими буквами. щас их не много к примеру:

Цитата

fillclose
memalpha
perimscale
threshold

Код


map<string, stringstream>

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

Код


int num;
string str;
param["num"] >> num;
param["str"] >> str;

bsa

Дата 23.11.2011, 15:17 (ссылка)

(голосов:2)

Загрузка ...

Эксперт

Профиль
Группа: Модератор
Сообщений: 9185
Регистрация: 6.4.2006
Где: Москва, Россия

Репутация: 63
Всего: 196

Цитата(RinOSpro @ 23.11.2011, 15:45

)

stringstream что бы можно было в любой тип легко преобразовывать.

ну ты извращенец!!!
Для этих целей существует такой тип Variant. К сожалению, стандартного нет. А тот что в бусте вообще какой-то странный. Но сделать сам ты его можешь.
Я его в свое время делал так:

Код

#ifndef VARIANT_HPP_
# define VARIANT_HPP_

# include <sstream>
# include <memory>
# include <typeinfo>
# include <algorithm>
# include <string>

//-----------------------------------------------------------------------------
template<typename Type>
inline std::string stringFrom(Type value)
{
    std::ostringstream stream;
    stream << value;
    return stream.str();
}
inline const std::string& stringFrom(const std::string &v) { return v; }
//-----------------------------------------------------------------------------
class DLLEXPORT Variant
{
    template<typename ValueType>
    class Holder;
public:
    Variant() : holder_(0) {}
    Variant(const Variant& v) : holder_(v.holder_ ? v.holder_->clone() : 0) {}

    Variant(const char *v) : holder_( new Holder<std::string>(v) ) {}

    template<typename ValueType>
    Variant(const ValueType &v) : holder_( new Holder<ValueType>(v) ) {}

    ~Variant() { delete holder_; }

    inline const std::type_info& type() const;

    inline Variant& operator=(Variant v);

    template<typename DestType>
    inline DestType cast() const;

    void swap(Variant &v) { std::swap(v.holder_, holder_); }
    bool empty() const throw() { return holder_ == 0; }

    inline bool operator==(const Variant &v) const;
private:
    class PlaceHolder {
    public:
        PlaceHolder(){}
        virtual ~PlaceHolder(){}
        virtual const std::type_info& type() const = 0;
        virtual PlaceHolder* clone() const = 0;
        virtual std::ostream& to_stream(std::ostream &stream) const = 0;
        virtual std::istream& from_stream(std::istream &stream) = 0;
        virtual bool compare(const PlaceHolder &ph) const = 0;
    private:
        PlaceHolder(const PlaceHolder &);
        PlaceHolder& operator=(const PlaceHolder &);
    };
    template<typename ValueType>
    class Holder : public PlaceHolder {
    public:
        Holder(const ValueType &val) : data_(val) {}
        virtual const std::type_info& type() const { return typeid(data_); }
        virtual Holder* clone() const { return new Holder(data_); }
        virtual std::ostream& to_stream(std::ostream &stream) const { return stream << data_; }
        virtual std::istream& from_stream(std::istream &stream) { return stream >> data_; }
        virtual inline bool compare(const PlaceHolder &ph) const;
        const ValueType& data() const throw() { return data_; }
    private:
        ValueType data_;
    };

    template<typename DestType>
    inline void lexical_cast(DestType &v) const;

    PlaceHolder *holder_;
};
//-----------------------------------------------------------------------------
const std::type_info& Variant::type() const
{
    return holder_ ? holder_->type() : typeid(void);
}
//-----------------------------------------------------------------------------
Variant& Variant::operator=(Variant v)
{
    swap(v);
    return *this;
}
//-----------------------------------------------------------------------------
template<typename DestType>
DestType Variant::cast() const
{
    DestType result = DestType();
    if (holder_ != 0) {
        if ( typeid(DestType) == holder_->type() ) {
//            typedef boost::remove_reference<DestType>::type nonref;
            return static_cast<const Holder<DestType>*>(holder_)->data();
        }
        lexical_cast(result);
    }
    return result;
}
//-----------------------------------------------------------------------------
template<typename DestType>
void Variant::lexical_cast(DestType &v) const
{
    DestType x = DestType();
    {
        std::stringstream stream;
        holder_->to_stream(stream);
        stream >> x;
    }
    std::auto_ptr<PlaceHolder> ph( holder_->clone() );
    {
        std::stringstream stream;
        stream << x;
        ph->from_stream( stream );
    }
    if ( !holder_->compare(*ph) )
        throw std::bad_cast("Variant: bad cast");
    std::swap(x, v);
}
//-----------------------------------------------------------------------------
template<>
inline void Variant::lexical_cast(std::string &v) const
{
    std::ostringstream stream;
    holder_->to_stream(stream);
    v = stream.str();
}
//-----------------------------------------------------------------------------
template<>
inline void Variant::lexical_cast(bool &v) const
{
    std::ostringstream stream;
    holder_->to_stream(stream);
    v = boolFromString(stream.str());
}
//-----------------------------------------------------------------------------
bool Variant::operator==(const Variant &v) const
{
    bool e1 = empty();
    bool e2 = v.empty();
    if (e1 || e2)
        return e1 && e2;    //true if both empty
    return holder_->compare(*v.holder_);
}
//-----------------------------------------------------------------------------
template<typename ValueType>
bool Variant::Holder<ValueType>::compare(const PlaceHolder &ph) const
{
    if ( Holder::type() == ph.type() )
        return (static_cast<const Holder&>(ph).data_ == data_);
    std::ostringstream stream1, stream2;
    ph.to_stream(stream1);
    to_stream(stream2);
    return stream1.str() == stream2.str();
}
//-----------------------------------------------------------------------------
template<typename DestType>
inline DestType variant_cast(const Variant& v)
{
    return v.cast<DestType>();
}
//-----------------------------------------------------------------------------
namespace std {
inline void swap(Core::Variant &v1, Core::Variant &v2)
{
    v1.swap(v2);
}
}    //namespace std
//-----------------------------------------------------------------------------
#endif /* VARIANT_HPP_ */

Если добавить операторы << и >>, которые будут вызывать метод cast, то получишь именно необходимую тебе функциональность.

Это сообщение отредактировал(а) bsa - 23.11.2011, 15:20

--------------------

Правильно заданный вопрос - половина ответа
Отзывы о работе модератора.

boostcoder

Дата 23.11.2011, 15:33 (ссылка)

(нет голосов)

Загрузка ...

pattern`щик

Профиль
Группа: Завсегдатай
Сообщений: 5458
Регистрация: 1.4.2010

Репутация: 49
Всего: 110

Цитата(bsa @ 23.11.2011, 15:17

)

ну ты извращенец!!!
Для этих целей существует такой тип Variant.

с++ славится статической типизацией. по этому, Variant, в любом случае костыль.

RinOSpro, объясни задачу более полно. чего мы тут гадаем...

--------------------

компилятор онлайн с поддержкой C++11
сборки компиляторов MinGW

RinOSpro

Дата 23.11.2011, 15:53 (ссылка)

(голосов: 0)

Загрузка ...

Unregistered

Цитата(boostcoder @ 23.11.2011, 15:33

)

RinOSpro, объясни задачу более полно. чего мы тут гадаем...

В DLL поступают параметры в виде (сhar* name, char* value) (GUI написан на другом языке)
И мне нужно составить пары name -> value.
Что бы потом можно было легко и просто получить параметры примерно так, вне зависимотри от типа:

Код


bool fillclose << param["fillclose"];
float memalpha << param["memalpha"];
int perimscale << param["perimscale"];
int threshold << param["threshold"];

boostcoder блин... и я только щас после того как написал класс обертку (см ниже). понял что туплю... stringstream после << будет очищаться....((

Цитата(bsa @ 23.11.2011, 15:17

)

ну ты извращенец!!!

Ты еще не видел что какое чудовище у меня получилось))

Код


class sswraper
{
public:
    auto_ptr<stringstream> s;

    sswraper(const sswraper& ssw)
    {
        stringstream *sn = new stringstream();
        (*sn) << ssw.s.get()->rdbuf();
        s.reset( sn );
    }

    sswraper()
    {
        s.reset(new stringstream);
    }
};

map<string, sswraper> params;

// используем так
    sswraper ssw;
    *ssw.s << avalue;
    params[name] = ssw;

    *(params[name].s) >> sss;

mes

Дата 23.11.2011, 23:28 (ссылка)

(нет голосов)

Загрузка ...

любитель

Профиль
Группа: Участник Клуба
Сообщений: 7954
Регистрация: 14.1.2006

Репутация: 144
Всего: 250

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

Добавлено через 3 минуты и 6 секунд

Цитата(boostcoder @ 23.11.2011, 14:33

)

с++ славится статической типизацией. по этому, Variant, в любом случае костыль.

как категорично.. и дисколи прям так и была нацелена на статическую типизацию..
однако не статической типизацией единной сыт программист smile

--------------------

http://opendots.net

Lols

Дата 24.11.2011, 03:09 (ссылка)

(нет голосов)

Загрузка ...

Шустрый

Профиль
Группа: Участник
Сообщений: 144
Регистрация: 21.10.2011

Репутация: нет
Всего: нет

Не понял как это применить к моему случаю, там предлагают использовать std::move.

Я вот тоже. У кого какие мысли по этому поводу?

RinOSpro

Дата 24.11.2011, 09:22 (ссылка)

(голосов: 0)

Загрузка ...

Unregistered

Цитата(mes @ 23.11.2011, 23:28

)

основных варианта два : обертка над картой или оберка над элементом карты

Угу так собственно и сделал...

Код


#ifndef PARAMS_H
#define PARAMS_H

#include <map>
#include <string>

using namespace std;

class Params
{
private:
    map<string, string> params;
public:
    string& operator[](string n);

    int Int(string n);
    bool Bool(string n);
    string Str(string n);
    float Float(string n);
    double Double(string n);
};

#endif // PARAMS_H

Код


#include "params.h"
#include <sstream>

string& Params::operator[](string n)
{
    return params[n];
}

int Params::Int(string n)
{
    int result;

    stringstream s;
    s << params[n];
    s >> result;

    return result;
}

float Params::Float(string n)
{
    float result;

    stringstream s;
    s << params[n];
    s >> result;

    return result;
}

double Params::Double(string n)
{
    double result;

    stringstream s;
    s << params[n];
    s >> result;

    return result;
}

bool Params::Bool(string n)
{
    bool result;

    stringstream s;
    s << params[n];
    s >> result;

    return result;
}

string Params::Str(string n)
{
    string result;

    stringstream s;
    s << params[n];
    s >> result;

    return result;
}

Использую так:
Для установки значений

Код


    params[name] = value;

Для получения значений:

Код


    int threshold = params.Int("threshold");
    int minrect = params.Int("minrect");
    double memalpha = params.Double("memalpha");
    int perimscale = params.Int("perimscale");
    bool fillclose = params.Bool("fillclose");

Если кто поможет написать перегрузку >> что бы работало как в stringstream буду очень благодарен.

Это сообщение отредактировал(а) RinOSpro - 24.11.2011, 09:24

0 Пользователей читают эту тему (0 Гостей и 0 Скрытых Пользователей)
0 Пользователей:
« Предыдущая тема \| C/C++: Общие вопросы \| Следующая тема »