Problem beim Anzeigen von Text ...

jkallup · 1. Dezember 2013

Hallo Gemeinde,

habe ein echt doofes Problem Text darzustellen (s. Markierung)

Code:

#ifdef __MAIN_RUN__
MyQVariant speichervar = 0.00;
MyQVariant strtest1 = QString();
#endif


	speichervar = MyQVariant(210.250000 + 2.000000);
	print_console(MyQVariant(speichervar)); // das geht noch

	strtest1 = QString("das ist gross").toUpper();
	print_console(strtest1); // <-- hier das nicht

	speichervar = QString("Keine kleinSchrifT").toUpper();
	print_console(MyQVariant(speichervar)); // <--- hier dito




void print_console(QString val)
{
    //if (debug_console == 1)
    {
	#ifdef WIN32
        DWORD i;
        AllocConsole();
	#endif

        char buffer[2048];
	sprintf(buffer,"%s\n",val.toStdString().c_str());

	#ifdef WIN32
        WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE),buffer,strlen(buffer),&i,NULL);
	#else
	printf(buffer);
	#endif
    }
}

void print_console(double val)
{
    ///if (debug_console == 1)
    {
	#ifdef WIN32
        DWORD i;
        AllocConsole();
	#endif

        char buffer[2048];
        sprintf(buffer,"%f\n",val);

	#ifdef WIN32
        WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE),buffer,strlen(buffer),&i,NULL);
	#else
	printf(buffer);
	#endif
    }
}

void print_console(MyQVariant x)
{
    //if (debug_console == 1)
    {
        if (x.value_type == MYQVAR_TYPE_DOUBLE( print_console(double (x.value_double)); else
        if (x.value_type == MYQVAR_TYPE_STRING) print_console(QString(x.value_string));
    }
}

#ifndef __MYQVARIANT_H__
#define __MYQVARIANT_H__

#include "all.h"

using namespace std;
using namespace boost;

class MyQVariant;

extern void print_console(double);
extern void print_console(QString);
extern void print_console(MyQVariant);
extern void print_console(MyQVariant*);
extern int  my_strlen (MyQVariant);

extern QString my_date_now(void);
extern QString my_time_now(void);

extern void my_set_time   (QString);

extern void msgbox(QString tstr, QString mstr);

extern void console_get_line(void);


#define MYQVAR_TYPE_DOUBLE 1
#define MYQVAR_TYPE_STRING 2

class MyQVariant: public QString
{
public:
    MyQVariant();
    MyQVariant(MyQVariant *);
    MyQVariant(double);
    MyQVariant(QString&);
    MyQVariant(QString);
    MyQVariant(int);
    MyQVariant(const int&);

    template<unsigned int N> MyQVariant(boost::multi_array<MyQVariant, N> &  );
    template<unsigned int N> MyQVariant(boost::multi_array<MyQVariant, N> &, boost::multi_array<MyQVariant, N> &);

    MyQVariant& operator += (MyQVariant&);
    MyQVariant& operator -= (MyQVariant&);
    MyQVariant& operator *= (MyQVariant&);
    MyQVariant& operator /= (MyQVariant&);

    MyQVariant& operator * (MyQVariant&);

    MyQVariant& operator += (double);
    MyQVariant& operator -= (double);
    MyQVariant& operator *= (double);
    MyQVariant& operator /= (double);

    MyQVariant& operator += (QString&);

    MyQVariant& operator = (double);
    MyQVariant& operator + (double);
    MyQVariant& operator - (double);
    MyQVariant& operator * (double);
    MyQVariant& operator / (double);

    MyQVariant& operator =  (int);
    MyQVariant& operator +  (int);
    MyQVariant& operator += (int);

    MyQVariant& operator = (QString);
    MyQVariant& operator + (QString);

    operator int () {
        this->value_type = MYQVAR_TYPE_DOUBLE;
        return static_cast<int>(this->value_double);
    }
    operator double () {
        this->value_type = MYQVAR_TYPE_DOUBLE;
        return static_cast<int>(this->value_double);
    }

    MyQVariant& operator = (MyQVariant&);

    bool operator == (double i) const { return ( this->value_double == i); }
    bool operator != (double i) const { return ( this->value_double != i); }

public:
    int     value_type;
    int      last_type;

    double  value_double;
    QString value_string;
};

class MyObjectTypes {
public:
    MyObjectTypes() { }
    int type;
    double value;
    QString str;
    QWidget *widget, *form;
    QString dbfview;
};

#ifdef __MAIN_RUN__
QVector<MyObjectTypes> f_types;
#else
extern QVector<MyObjectTypes> f_types;
#endif

#ifdef __MAIN_RUN__
template <typename Array>
void print(Array& A)
{
    typename Array::const_iterator i;
    QString s;

    s = QString("[");

    for (i = A.begin(); i != A.end(); ++i)
    {
        if (boost::next(i) != A.end())
        {
            s = s + static_cast<MyQVariant>(A).value_string;  // leer

            s = s + QString(",");
        }
    }

    s = s + QString("]");
    print_console(QString(s));
}

template<unsigned int N> MyQVariant::MyQVariant(boost::multi_array<MyQVariant, N> &A)
{
    A[0][0].value_string = QString("paule");
}

template<unsigned int N> MyQVariant::MyQVariant(boost::multi_array<MyQVariant, N> &E, boost::multi_array<MyQVariant, N> &A)
{
    std::vector<size_t> ex;
    const size_t* shape = A.shape();
    ex.assign(shape, shape + A.num_dimensions());

    E.resize(ex);
    E = A;
}

MyQVariant::MyQVariant()
{
    this->value_type = MYQVAR_TYPE_STRING;
}

MyQVariant::MyQVariant(MyQVariant *c)
{
    print_console(QString("ptr opj"));
    this->value_double = double (c->value_double);
    this->value_string = QString(c->value_string);

    this->value_type = c->value_type;
}

MyQVariant::MyQVariant(double val)
{
    value_type = MYQVAR_TYPE_DOUBLE;
    value_double = val;
}

// <obj> = QString
MyQVariant::MyQVariant(QString& str)
{
    this->value_type = MYQVAR_TYPE_STRING;
    this->value_string = str;
}

MyQVariant::MyQVariant(QString str)
{
    this->value_type = MYQVAR_TYPE_STRING;
    this->value_string = str;
}

MyQVariant::MyQVariant(int val)
{
    this->value_type = MYQVAR_TYPE_DOUBLE;
    this->value_double = val;
}

MyQVariant& MyQVariant::operator * (MyQVariant& rhs)
{
    print_console(QString("einfachmal"));
    this->value_type = MYQVAR_TYPE_DOUBLE;
    this->value_double =
    this->value_double +
    rhs.  value_double ;   return *this;
}

MyQVariant& MyQVariant::operator += (MyQVariant& rhs)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double +
    rhs.  value_double ; return *this;
}

MyQVariant& MyQVariant::operator += (QString& rhs)
{
    print_console(QString("<--55-->"));
    if (this->value_type == MYQVAR_TYPE_DOUBLE) {
        this->value_double =
        this->value_double + rhs.size() ;
        this->value_type  = MYQVAR_TYPE_DOUBLE; } else
    if (this->value_type == MYQVAR_TYPE_STRING) {
        this->value_string =
        this->value_string + rhs;
        this->value_type  = MYQVAR_TYPE_STRING;
    }

    return *this;
}

MyQVariant& MyQVariant::operator -= (MyQVariant& rhs)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double -
    rhs.  value_double ; return *this;
}

MyQVariant& MyQVariant::operator *= (MyQVariant& rhs)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double *
    rhs.  value_double ; return *this;
}

MyQVariant& MyQVariant::operator /= (MyQVariant& rhs)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double /
    rhs.  value_double ; return *this;
}

MyQVariant& MyQVariant::operator += (double val)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double + val; return *this;
}

MyQVariant& MyQVariant::operator -= (double val)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double - val; return *this;
}

MyQVariant& MyQVariant::operator *= (double val)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double * val; return *this;
}

MyQVariant& MyQVariant::operator /= (double val)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double / val; return *this;
}


MyQVariant& MyQVariant::operator += (int val)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double =
    this->value_double + val; return *this;
}

// <objref> = 123;
MyQVariant& MyQVariant::operator = (int rhs)
{
    this->last_type  = MYQVAR_TYPE_DOUBLE;
    this->value_type = MYQVAR_TYPE_STRING;
    this->value_string = QString::number(rhs);
    this->value_double = rhs;
    return *this;
}

MyQVariant& MyQVariant::operator = (double rhs)
{
    this->value_type = MYQVAR_TYPE_DOUBLE;
    this->value_double = rhs;
    return *this;
}

// <objref> = Qstring
MyQVariant& MyQVariant::operator = (QString rhs)
{
printf(": %s\n",rhs.toStdString().c_str());
    MyQVariant *tmp = new MyQVariant(QString(rhs));
    tmp->value_type = tmp->last_type = MYQVAR_TYPE_STRING;
    tmp->value_string = rhs;
    return *tmp;
}

MyQVariant& MyQVariant::operator + (int rhs)
{
    this->last_type  = MYQVAR_TYPE_DOUBLE;
    this->value_type = MYQVAR_TYPE_STRING;

    this->value_double += rhs;

    QString num = QString::number(this->value_double);
    int z = num.toInt();
    num = QString::number(z);

    this->value_string = num;
    return *this;
}

MyQVariant& MyQVariant::MyQVariant::operator + (QString val)
{
    print_console(QString("<--66-->"));
    this->value_type = MYQVAR_TYPE_STRING;
    this->value_string = this->value_string + val;
    return *this;
}

MyQVariant& MyQVariant::MyQVariant::operator + (double val)
{
    this->last_type  = MYQVAR_TYPE_DOUBLE;
    this->value_type = MYQVAR_TYPE_STRING;
    this->value_double = this->value_double + val;

    QString num = QString::number(this->value_double);
    int z = num.toInt();
    num = QString::number(z);

    this->value_string = num;
    return *this;
}

MyQVariant& MyQVariant::MyQVariant::operator - (double val)
{
    this->value_double = this->value_double - val;
    return *this;
}

MyQVariant& MyQVariant::MyQVariant::operator * (double val)
{
    print_console(QString("mal"));

    this->value_type   = MYQVAR_TYPE_DOUBLE ;
    this->value_double = this->value_double * val;
    return *this;
}

MyQVariant& MyQVariant::MyQVariant::operator / (double val)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double = this->value_double / val;
    return *this;
}

/*
MyQVariant& MyQVariant::operator + (int val)
{
    if (value_type == MYQVAR_TYPE_DOUBLE)
    this->value_double = this->value_double + val; else
    this->value_string = this->value_string + QString(val);
    return *this;
}
*/

MyQVariant& MyQVariant::operator = (MyQVariant& rhs)
{
    if (rhs.value_type == MYQVAR_TYPE_STRING)
    rhs.value_string = this->value_string;
    return *this;
}

QString operator + (double rhs, MyQVariant lhs)
{
    char buffer[2048];
    sprintf(buffer,"%s%f",lhs.value_string.toLatin1().data(),rhs);

printf("----> %s\n",buffer);

    lhs.value_type = MYQVAR_TYPE_STRING;
    lhs.value_string = QString(buffer);
    return lhs.value_string;
}

const char* operator + (const char* rhs, MyQVariant lhs)
{
    std::string res;
    res = std::string(rhs) + std::string(lhs.value_string.toLatin1().data());
    return res.c_str();
}

int operator - (int lhs, MyQVariant& rhs)
{
    rhs.value_type = MYQVAR_TYPE_DOUBLE;
    rhs.value_double -= lhs;
    return rhs.value_double;
}

int operator + (int lhs, MyQVariant& rhs)
{
    rhs.value_type = MYQVAR_TYPE_DOUBLE;
    rhs.value_double += lhs;
    return rhs.value_double;
}

int operator * (int lhs, MyQVariant& rhs)
{
    rhs.value_type = MYQVAR_TYPE_DOUBLE;
    rhs.value_double *= lhs;
    return rhs.value_double;
}

int operator / (int lhs, MyQVariant& rhs)
{
    rhs.value_type = MYQVAR_TYPE_DOUBLE;
    rhs.value_double /= lhs;
    return rhs.value_double;
}

// double = <objref> + <objref>
double operator + (MyQVariant lhs, MyQVariant& rhs)
{
    if (rhs.last_type == MYQVAR_TYPE_DOUBLE)
    {
        rhs.value_type = MYQVAR_TYPE_DOUBLE;
        rhs.value_double = lhs.value_double + rhs.value_double;
        rhs.value_string = QString::number(rhs.value_double);

        return rhs.value_double; 
    }
}

double operator - (double lhs, MyQVariant& rhs)
{
    rhs.value_type = MYQVAR_TYPE_DOUBLE;
    rhs.value_double -= lhs;
    return rhs.value_double;
}

double operator + (double lhs, MyQVariant& rhs)
{
    rhs.value_double += lhs;
    return rhs.value_double;
}

double operator * (double lhs, MyQVariant& rhs)
{
    print_console(QString("doublemmal"));
    rhs.value_double *= lhs;
    return rhs.value_double;
}

double operator / (double lhs, MyQVariant& rhs)
{
    rhs.value_double /= lhs;
    return rhs.value_double;
}

#endif

#endif

deepthroat · 1. Dezember 2013

Hi.

Dein Zuweisungsoperator ist fehlerhaft implementiert.

Da hat ein temporäres Objekt nichts zu suchen.

Bitte sage beim nächsten Mal auch dazu was nicht geht - am besten zeige die Eingabe und Ausgabe...

BTW, wenn du schon Boost benutzt, warum verwendest du denn nicht Boost.Variant?

Problem beim Anzeigen von Text ...

jkallup

Erfahrenes Mitglied

deepthroat

Erfahrenes Mitglied

Neue Beiträge