Problem beim Anzeigen von Text ...

jkallup

Erfahrenes Mitglied
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
 
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?
 

Neue Beiträge

Zurück