Перевод int и double в char*

@EfimKR · Регистрация: 24.06.2014

Author24 — интернет-сервис помощи студентам

Возникла следующая проблема. Нужно сделать:

C++

//Реализовать класс var - «Универсальная переменная». Объекты экземпляры этого класса способны 
//хранить в себе значения следующих типов: int, double, String (строка – уже готовый класс).
//Для класса var необходимо перегрузить арифметические операторы: +, -, *, /, +=, -=, *=, /=
//И операторы сравнения: <, >, <=, >=, ==, !=
//При перегрузке операторов учитывать следующее: 
//если в операции типы значений двух операндов типа var разные, то необходимо приводить 
//(конвертировать) значение из второго операнда к типу значения первого операнда и только после этого выполнять операцию.
//(При этом значение (и тип) второго операнда в самом объекте var не меняется)
//Для типа Строка операция * должна возвращать новую строку, 
//состоящую только из символов первой строки, которые есть во  второй строке.
//Для типа Строка операция / должна возвращать новую строку, состоящую 
//из символов первой строки, которых нет во второй строке.
//Аналогично для Строки *= и /= 
//Добавить в класс var преобразования к типам: int, double, char*

Все получилось кроме преобразования сhar*() для числовых значений. Перед преобразованием есть строка в формате С-строки с числом, после преобразования абра-кадабра. Вот последний вариант кода:

@EfimKR · 07.01.2015, 23:05 **[ТС]**

Кликните здесь для просмотра всего текста

C++

#include<iostream>
#include<string>
#include<sstream>
#include<windows.h>
using namespace std;
 
class Var
{
    enum Type {I, D, S};
    int nVar;
    double dVar;
    string sVar;
    Type type;
 
    template <typename T>
    string toString(T val);
    void DiffString( string& str1, int dl);         // реализация математических операций - для строк
    void MultString(string& s1, const string& s2);  // доступны только для данного класса
    void DivString(string& s1, const string& s2);
 
public:
    Var(int n);
    Var(double d);
    Var(string s);
 
    Var& operator+=(const Var&);
    Var& operator-=(const Var&);
    Var& operator*=(const Var&);
    Var& operator/=(const Var&);
 
    Var operator+ (const Var&);
    Var operator- (const Var&);
    Var operator* (const Var&);
    Var operator/ (const Var&);
 
    bool operator==(const Var&);
    bool operator>(const Var&);
    bool operator<(const Var&);
    bool operator>=(const Var&);
    bool operator<=(const Var&);
    bool operator!=(const Var&);
 
    void Show() const;
 
    operator int();
    operator double();
    operator const char*();
};
 
template <typename T> 
string Var::toString(T val)
{
    ostringstream oss;
    oss<< val;
    return oss.str();
}
 
void Var::DiffString(string& str1, int dl)
{
    int t = 0;
    if (str1.size() > dl)
        t = str1.size() - dl;
    str1.resize(t);
}
 
void Var::MultString(string& s1, const string& s2)
{
    string tmp;
    for (int i = 0; i < s1.size(); i++)
        if (s2.find(s1[i]) != -1)
            tmp+=s1[i];
    s1 = tmp;
}
 
void Var::DivString(string& s1, const string& s2)
{
    string tmp;
    for (int i = 0; i < s1.size(); i++)
        if (s2.find(s1[i]) == -1)
            tmp+=s1[i];
    s1 = tmp;
}
 
Var::Var(int n = 0)
{
    type = I;
    nVar = n;
    dVar = NULL;
    sVar = "";
}
 
Var::Var(double d)
{
    type = D;
    nVar = NULL;
    dVar = d;
    sVar = "";
}
 
Var::Var(string s)
{
    type = S;
    nVar = NULL;
    dVar = NULL;
    sVar = s;
}
 
Var& Var::operator+=(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
        {
            nVar += V.nVar;
            return *this;
        }
        if (V.type == D)
        {
            nVar += int(V.dVar);
            return *this;
        }
        if (V.type == S)
        {
            nVar += int((V.sVar).c_str());
            return *this;
        }
    }
    if (type == D)
    {
        if (V.type == I)
        {
            dVar += double(V.nVar);
            return *this;
        }
        if (V.type == D)
        {
            dVar += V.dVar;
            return *this;
        }
        if (V.type == S)
        {
            dVar += double(int((V.sVar).c_str()));
            return *this;
        }
    }
    if (type == S)
    {
        if (V.type == I)
        {
            sVar += toString(V.nVar);
            return *this;
        }
        if (V.type == D)
        {
            sVar += toString(V.dVar);
            return *this;
        }
        if (V.type == S)
        {
            sVar += V.sVar;
            return *this;
        }
    }
}
 
Var& Var::operator-=(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
        {
            nVar -= V.nVar;
            return *this;
        }
        if (V.type == D)
        {
            nVar -= int(V.dVar);
            return *this;
        }
        if (V.type == S)
        {
            nVar -= int((V.sVar).c_str());
            return *this;
        }
    }
    if (type == D)
    {
        if (V.type == I)
        {
            dVar -= double(V.nVar);
            return *this;
        }
        if (V.type == D)
        {
            dVar -= V.dVar;
            return *this;
        }
        if (V.type == S)
        {
            dVar -= double(int((V.sVar).c_str()));
            return *this;
        }
    }
    if (type == S)
    {
        if (V.type == I)
        {
            DiffString(sVar,(toString(V.nVar)).size());
            return *this;
        }
        if (V.type == D)
        {
            DiffString(sVar,(toString(V.dVar)).size());
            return *this;
        }
        if (V.type == S)
        {
            DiffString(sVar,(V.sVar).size());
            return *this;
        }
    }
}
 
Var& Var::operator*=(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
        {
            nVar *= V.nVar;
            return *this;
        }
        if (V.type == D)
        {
            nVar *= int(V.dVar);
            return *this;
        }
        if (V.type == S)
        {
            nVar *= int((V.sVar).c_str());
            return *this;
        }
    }
    if (type == D)
    {
        if (V.type == I)
        {
            dVar *= double(V.nVar);
            return *this;
        }
        if (V.type == D)
        {
            dVar *= V.dVar;
            return *this;
        }
        if (V.type == S)
        {
            dVar *= double(int((V.sVar).c_str()));
            return *this;
        }
    }
    if (type == S)
    {
        if (V.type == I)
        {
            MultString(sVar,toString(V.nVar));
            return *this;
        }
        if (V.type == D)
        {
            MultString(sVar, toString(V.dVar));
            return *this;
        }
        if (V.type == S)
        {
            MultString(sVar, V.sVar);
            return *this;
        }
    }
}
 
Var& Var::operator/=(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
        {
            if (!V.nVar)
            {
                cout<<"Деление на 0!\n";
                return *this;
            }
            nVar /= V.nVar;
            return *this;
        }
        if (V.type == D)
        {
            if (!V.dVar)
            {
                cout<<"Деление на 0!\n";
                return *this;
            }
            nVar /= int(V.dVar);
            return *this;
        }
        if (V.type == S)
        {
            if (!int((V.sVar).c_str()))
            {
                cout<<"Деление на 0!\n";
                return *this;
            }
            nVar /= int((V.sVar).c_str());
            return *this;
        }
    }
    if (type == D)
    {
        if (V.type == I)
        {
            if (!V.nVar)
            {
                cout<<"Деление на 0!\n";
                return *this;
            }
            dVar /= double(V.nVar);
            return *this;
        }
        if (V.type == D)
        {
            if (!V.dVar)
            {
                cout<<"Деление на 0!\n";
                return *this;
            }
            dVar /= V.dVar;
            return *this;
        }
        if (V.type == S)
        {
            if (!int((V.sVar).c_str()))
            {
                cout<<"Деление на 0!\n";
                return *this;
            }
            dVar /= double(int((V.sVar).c_str()));
            return *this;
        }
    }
    if (type == S)
    {
        if (V.type == I)
        {
            DivString(sVar, toString(V.nVar));
            return *this;
        }
        if (V.type == D)
        {
            DivString(sVar, toString(V.dVar));
            return *this;
        }
        if (V.type == S)
        {
            DivString(sVar, V.sVar);
            return *this;
        }
    }
}
 
Var Var::operator+ (const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
        {
            return Var(nVar + V.nVar);  
        }
        if (V.type == D)
        {
            return Var(nVar + int(V.dVar));
        }
        if (V.type == S)
        {
            return Var(nVar + int((V.sVar).c_str()));
        }
    }
    if (type == D)
    {
        if (V.type == I)
        {
            return Var(dVar + double(V.nVar));
        }
        if (V.type == D)
        {
            return Var(dVar + V.dVar);
        }
        if (V.type == S)
        {
            return Var(dVar + double(int((V.sVar).c_str())));
        }
    }
    if (type == S)
    {
        if (V.type == I)
        {
            return Var(sVar + toString(V.nVar));
        }
        if (V.type == D)
        {
            return Var(sVar + toString(V.dVar));
        }
        if (V.type == S)
        {
            return (sVar + V.sVar);
        }
    }
}
 
Var Var::operator- (const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
        {
            return Var(nVar - V.nVar);  
        }
        if (V.type == D)
        {
            return Var(nVar - int(V.dVar));
        }
        if (V.type == S)
        {
            return Var(nVar - int((V.sVar).c_str()));
        }
    }
    if (type == D)
    {
        if (V.type == I)
        {
            return Var(dVar - double(V.nVar));
        }
        if (V.type == D)
        {
            return Var(dVar - V.dVar);
        }
        if (V.type == S)
        {
            return Var(dVar - double(int((V.sVar).c_str())));
        }
    }
    if (type == S)
    {
        string tmp = sVar;
        if (V.type == I)
        {
            DiffString(tmp, (toString(V.nVar)).size());
            return Var(tmp);
        }
        if (V.type == D)
        {
            DiffString(tmp, (toString(V.dVar)).size());
            return Var(tmp);
        }
        if (V.type == S)
        {
            DiffString(tmp, V.sVar.size());
            return (tmp);
        }
    }
}
 
Var Var::operator* (const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
        {
            return Var(nVar * V.nVar);  
        }
        if (V.type == D)
        {
            return Var(nVar * int(V.dVar));
        }
        if (V.type == S)
        {
            return Var(nVar * int((V.sVar).c_str()));
        }
    }
    if (type == D)
    {
        if (V.type == I)
        {
            return Var(dVar * double(V.nVar));
        }
        if (V.type == D)
        {
            return Var(dVar * V.dVar);
        }
        if (V.type == S)
        {
            return Var(dVar * double(int((V.sVar).c_str())));
        }
    }
    if (type == S)
    {
        string tmp = sVar;
        if (V.type == I)
        {
            MultString(tmp, toString(V.nVar));
            return Var(tmp);
        }
        if (V.type == D)
        {
            MultString(tmp, toString(V.dVar));
            return Var(tmp);
        }
        if (V.type == S)
        {
            MultString(tmp, V.sVar);
            return (tmp);
        }
    }
}
 
Var Var::operator/ (const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
        {
            if (!V.nVar)
            {
                cout<<"Деление на 0!\n";
                return Var();
            }
            return Var(nVar / V.nVar);  
        }
        if (V.type == D)
        {
            if (!V.dVar)
            {
                cout<<"Деление на 0!\n";
                return Var();
            }
            return Var(nVar / int(V.dVar));
        }
        if (V.type == S)
        {
            if (!int((V.sVar).c_str()))
            {
                cout<<"Деление на 0!\n";
                return Var();
            }
            return Var(nVar / int((V.sVar).c_str()));
        }
    }
    if (type == D)
    {
        if (V.type == I)
        {
            if (!V.nVar)
            {
                cout<<"Деление на 0!\n";
                return Var();
            }
            return Var(dVar / double(V.nVar));
        }
        if (V.type == D)
        {
            if (!V.dVar)
            {
                cout<<"Деление на 0!\n";
                return Var();
            }
            return Var(dVar / V.dVar);
        }
        if (V.type == S)
        {
            if (!int((V.sVar).c_str()))
            {
                cout<<"Деление на 0!\n";
                return Var();
            }
            return Var(dVar / double(int((V.sVar).c_str())));
        }
    }
    if (type == S)
    {
        string tmp = sVar;
        if (V.type == I)
        {
            DivString(tmp, toString(V.nVar));
            return Var(tmp);
        }
        if (V.type == D)
        {
            DivString(tmp, toString(V.dVar));
            return Var(tmp);
        }
        if (V.type == S)
        {
            DivString(tmp, V.sVar);
            return (tmp);
        }
    }
}
 
bool Var::operator==(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
            return (nVar == V.nVar);
        if (V.type == D)
            return (nVar == int(V.dVar));
        if (V.type == S)
            return (nVar == int((V.sVar).c_str()));
    }
    if (type == D)
    {
        if (V.type == I)
            return (dVar == double(V.nVar));
        if (V.type == D)
            return (dVar == V.dVar);
        if (V.type == S)
            return (dVar == double(int((V.sVar).c_str())));
    }
    if (type == S)
    {
        if (V.type == I)
            return (sVar == toString(V.nVar));
        if (V.type == D)
            return (sVar == toString(V.dVar));
        if (V.type == S)
            return (sVar == V.sVar);
    }
}
 
bool Var::operator>(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
            return (nVar > V.nVar);
        if (V.type == D)
            return (nVar > int(V.dVar));
        if (V.type == S)
            return (nVar > int((V.sVar).c_str()));
    }
    if (type == D)
    {
        if (V.type == I)
            return (dVar > double(V.nVar));
        if (V.type == D)
            return (dVar > V.dVar);
        if (V.type == S)
            return (dVar > double(int((V.sVar).c_str())));
    }
    if (type == S)
    {
        if (V.type == I)
            return (sVar > toString(V.nVar));
        if (V.type == D)
            return (sVar > toString(V.dVar));
        if (V.type == S)
            return (sVar > V.sVar);
    }
}
 
bool Var::operator<(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
            return (nVar < V.nVar);
        if (V.type == D)
            return (nVar < int(V.dVar));
        if (V.type == S)
            return (nVar < int((V.sVar).c_str()));
    }
    if (type == D)
    {
        if (V.type == I)
            return (dVar < double(V.nVar));
        if (V.type == D)
            return (dVar < V.dVar);
        if (V.type == S)
            return (dVar < double(int((V.sVar).c_str())));
    }
    if (type == S)
    {
        if (V.type == I)
            return (sVar < toString(V.nVar));
        if (V.type == D)
            return (sVar < toString(V.dVar));
        if (V.type == S)
            return (sVar < V.sVar);
    }
}
bool Var::operator>=(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
            return (nVar >= V.nVar);
        if (V.type == D)
            return (nVar >= int(V.dVar));
        if (V.type == S)
            return (nVar >= int((V.sVar).c_str()));
    }
    if (type == D)
    {
        if (V.type == I)
            return (dVar >= double(V.nVar));
        if (V.type == D)
            return (dVar >= V.dVar);
        if (V.type == S)
            return (dVar >= double(int((V.sVar).c_str())));
    }
    if (type == S)
    {
        if (V.type == I)
            return (sVar >= toString(V.nVar));
        if (V.type == D)
            return (sVar >= toString(V.dVar));
        if (V.type == S)
            return (sVar >= V.sVar);
    }
}
 
bool Var::operator<=(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
            return (nVar <= V.nVar);
        if (V.type == D)
            return (nVar <= int(V.dVar));
        if (V.type == S)
            return (nVar <= int((V.sVar).c_str()));
    }
    if (type == D)
    {
        if (V.type == I)
            return (dVar <= double(V.nVar));
        if (V.type == D)
            return (dVar <= V.dVar);
        if (V.type == S)
            return (dVar <= double(int((V.sVar).c_str())));
    }
    if (type == S)
    {
        if (V.type == I)
            return (sVar <= toString(V.nVar));
        if (V.type == D)
            return (sVar <= toString(V.dVar));
        if (V.type == S)
            return (sVar <= V.sVar);
    }
}
bool Var::operator!=(const Var& V)
{
    if (type == I)
    {
        if (V.type == I)
            return (nVar != V.nVar);
        if (V.type == D)
            return (nVar != int(V.dVar));
        if (V.type == S)
            return (nVar != int((V.sVar).c_str()));
    }
    if (type == D)
    {
        if (V.type == I)
            return (dVar != double(V.nVar));
        if (V.type == D)
            return (dVar != V.dVar);
        if (V.type == S)
            return (dVar != double(int((V.sVar).c_str())));
    }
    if (type == S)
    {
        if (V.type == I)
            return (sVar != toString(V.nVar));
        if (V.type == D)
            return (sVar != toString(V.dVar));
        if (V.type == S)
            return (sVar != V.sVar);
    }
}
void Var::Show() const
{
    if (type == I)
        cout<<"Тип переменной: int. Значение: "<<nVar<<endl;
    if (type == D)
        cout<<"Тип переменной: double. Значение: "<<dVar<<endl;
    if (type == S)
        cout<<"Тип переменной: string. Значение: "<<sVar<<endl;
}
 
Var::operator int()
{
    if (type == I)
        return nVar;
    if (type == D)
        return int(dVar);
    if (type == S)
        return int(sVar.c_str());
}
Var::operator double()
{
    if (type == I)
        return double(nVar);
    if (type == D)
        return dVar;
    if (type == S)
        return double(int(sVar.c_str()));
}
Var::operator const char*()
{
    if (type == I)
    {
        string tmp = toString(nVar);
        return tmp.c_str();
    }
    if (type == D)
    {
        string tmp = toString(dVar);
        return tmp.c_str();;
    }
    if (type == S)
        return sVar.c_str();
}
 
int main()
{
    SetConsoleCP (1251);
    SetConsoleOutputCP (1251);
 
    Var a(1), b(2), f(0);
    cout<<"a = ";
    a.Show();
    cout<<"b = ";
    b.Show();
    cout<<"f = ";
    f.Show();
 
    cout<<"(a!=b)"<<(a!=b)<<endl;
    cout<<"(a<=b)"<<(a<=b)<<endl;
 
 
    
    cout<<"int(a) "<<int(a)<<endl;
    cout<<"double(a) "<<double(a)<<endl;
    cout<<"char*(a) "<<(const char*)a<<endl;
 
 
 
 
    return 0;
}

Добавлено через 1 минуту
Вот отдельно реализация функции приведения:

C++

Var::operator const char*()
{
    if (type == I)
    {
        string tmp = toString(nVar);
        return tmp.c_str();
    }
    if (type == D)
    {
        string tmp = toString(dVar);
        return tmp.c_str();;
    }
    if (type == S)
        return sVar.c_str();
}

Tulosba · 07.01.2015, 23:12

Сообщение от EfimKR

после преобразования абра-кадабра.

Пример кода с кривым выводом можно увидеть?

@EfimKR · 07.01.2015, 23:18 **[ТС]**

Правильно работает вот так:

C++

Var::operator char*()
{
    if (type == I)
    {
        string tmp = toString(nVar);
        char *r = new char[tmp.size()];
        strcpy(r,tmp.c_str());
        r[tmp.size()]='\0';
        return r;
    }
    if (type == D)
    {
        string tmp = toString(dVar);
        char *r = new char[tmp.size()];
        strcpy(r,tmp.c_str());
        r[tmp.size()]='\0';
        return r;
    }
    if (type == S)
        return (char*)sVar.c_str();
}

Но при этом теряется память.

Добавлено через 1 минуту
Tulosba, под спойлером вся программа, форумный редактор на размер текста ругался, пришлось обрезать main.

Tulosba · 07.01.2015, 23:21

Сообщение от EfimKR

под спойлером вся программа

Программу вижу, но не вижу вывода абракадабры. Всё честно выводит:
http://ideone.com/3vIwO0

@EfimKR · 07.01.2015, 23:32 **[ТС]**

Tulosba, хм, возможно это Visual Studio выделывается. Что только не делал, но пока не выделил память в куче выводило мусор.

Tulosba · 07.01.2015, 23:35

Сообщение от EfimKR

возможно это Visual Studio выделывается.

Скорее всего просто где-то идет "сёр" в память или чтение уже освобожденной или неинициализированной памяти.

@EfimKR · 08.01.2015, 21:06 **[ТС]**

Tulosba, как можно это определить и устранить?

Добавлено через 1 минуту
И почему для string переменной все работает нормально?

Добавлено через 21 час 26 минут
Tulosba, если интересно, то вот так решил эту проблему.

C++

Var::operator char*()
{
 
    if (type == I)
    {
        sVar = toString(nVar);
        return (char*)sVar.c_str(); 
    }
    if (type == D)
    {
        sVar = toString(dVar);
        return (char*)sVar.c_str();
    }
    if (type == S)
        return (char*)sVar.c_str();
}

Проблема была в том, что строка дохла до возврата в main, так как была создана в функции. Теперь же она живет подольше и всё работает.

Tulosba :) 4773 / 3267 / 497 Регистрация: 19.02.2013 Сообщений: 9,046
	07.01.2015, 23:12	3
	Сообщение от EfimKR после преобразования абра-кадабра. Пример кода с кривым выводом можно увидеть? 0

Tulosba :) 4773 / 3267 / 497 Регистрация: 19.02.2013 Сообщений: 9,046
	07.01.2015, 23:21	5
	Сообщение от EfimKR под спойлером вся программа Программу вижу, но не вижу вывода абракадабры. Всё честно выводит: http://ideone.com/3vIwO0 1

@EfimKR 57 / 30 / 13 Регистрация: 24.06.2014 Сообщений: 255 Записей в блоге: 1
	07.01.2015, 23:32 [ТС]	6
	Tulosba, хм, возможно это Visual Studio выделывается. Что только не делал, но пока не выделил память в куче выводило мусор. 0

Tulosba :) 4773 / 3267 / 497 Регистрация: 19.02.2013 Сообщений: 9,046
	07.01.2015, 23:35	7
	Сообщение от EfimKR возможно это Visual Studio выделывается. Скорее всего просто где-то идет "сёр" в память или чтение уже освобожденной или неинициализированной памяти. 0

	08.01.2015, 21:06

Опции темы