== Operator überladen

Hallo,

ich muss von der Schule aus eine eigene String Klasse schreiben. Dabei soll unter anderem auch der == Operator überladen werden. Jetzt stellt sich mir die Frage wieso mein Testprogramm auch wenn die beiden Strings die verglichen werden sollen gleich sind, nicht in die if-Anweisung reinspringt.

Hier der Code:

main

#include <QtCore/QCoreApplication>

#include <stdio.h>
#include <QDebug>
#include "mystring.h"

int main(int argc, char *argv[])
{

    const char *ptr = "Irgendwas";
    const char *ptr2 = "Irgendwas";
    MyString * lol = new MyString(ptr);
    MyString * lol2 = new MyString(ptr2);
    lol->display();
    lol2->display();

    if(lol==lol2){
        qDebug()<< "Yes";
    }
    else{
        qDebug()<<"No";
    }

   return 0;
}

mystring Klasse:

#include "mystring.h"
#include "string.h"
#include <stdio.h>
#include <stdlib.h>
#include <QDebug>

using namespace std;

MyString::MyString()
{
    m_len=0;
    m_string = new char[1];
}

MyString::MyString(const char *pstr){
    m_len = strlen(pstr);
    m_string = new char [m_len+1];
    m_string = strcpy(m_string,pstr);
}

MyString::MyString(int plen){
    m_len = plen;
    m_string = new char [m_len+1];
}

MyString::MyString(char ch, int n){
    m_len = n;
    m_string = new char [m_len+1];
    for(int i=0;i<m_len;++i){
        m_string[i]=ch;
    }
    m_string[m_len] = '\0';
}

MyString::~MyString(){
    free(m_string);
}

int comp(const void *elem1, const void *elem2){
    return *(char*)elem1 - *(char*)elem2;
}

void MyString::sort(){
   return qsort(m_string,m_len,sizeof(char),comp);
}

char MyString::get(int p) const{
    return m_string[p-1];
}

void MyString::set(int p, char ch){
    m_string[p-1] = ch;
}

void MyString::display () const{
    for(int i=0;m_string[i]!='\0';++i){
        qDebug() << m_string[i];
    }
}

bool MyString::operator==(const char *s){
    qDebug()<<"Drin";
    if(strcmp(m_string,s)==0){
        return true;
    }
    else{
        return false;
    }
}

mystring Header:

#ifndef MYSTRING_H
#define MYSTRING_H

#include <ostream>

using namespace std;

class MyString
{
private:
    char* m_string;
    int m_len;

public:
    MyString();
    MyString(const char* pstr);
    MyString(int plen);
    MyString(char ch, int n);

    void sort();
    char get(int p) const;
    void set(int p, char ch);
    void display() const;
    ~MyString();

    // void append(const char* pstr);

    // friend ostream& operator<<(ostream& o, const MyString& e);
   bool operator==(const char *s);
   // bool operator==(const MyString& e);

   // MyString& operator=(const MyString& e);
    // MyString(const MyString& e);

    //char& operator[](int i);
    //char operator[](int i) const;

    //MyString operator+(const MyString& e);
};

#endif // MYSTRING_H

Hoffe mir kann jemand weiterhelfen da ich langsam keine lust mehr habe ratlos auf das Programm zu starren ^^

pyhax

Da du in main mit Zeigern arbeitest (was aber keinen Sinn macht), musst du diese auch Dereferzieren:

if(*lol == *lol2) {

( Benutze bitte beim nächsten Mal statt Code den C/C++ Button für Quellcode, dann sieht es so schön farbig aus )

Außerdem gibts du den Speicher nicht wieder frei:

delete lol;
delete lol2;

Und hier noch die Variante ohne Zeiger und dynamische Speicheranforderungen (besser! Benutze besser diese Variante)

#include <QtCore/QCoreApplication>

#include <stdio.h>
#include <QDebug>
#include "mystring.h"

int main(int argc, char *argv[])
{

    const char *ptr = "Irgendwas";
    const char *ptr2 = "Irgendwas";
    MyString lol(ptr);
    MyString lol2(ptr);
    lol->display();
    lol2->display();

    if(lol==lol2){
        qDebug()<< "Yes";
    }
    else{
        qDebug()<<"No";
    }

   return 0;
}

PS: Kommst du von Java? Da muss man alles mit new Anfordern, aber Java hat im Gegensatz zu C++ einen Gabarge Collector.

Jep ich hab bisher eigentlich immer mit Java gearbeitet, da fällt es noch schwer sich daran zu gewöhnen, dass in C++ der Garbage Collector nicht hinterher putzt

pyhax

Allerdings, wie ich schon gesagt habe, brauchst du hier gar kein new/delete.

Ok. Übrigens danke für die Hilfe, jetzt läufts

theta

@pyhax: Naja, das kleine Bsp. welches mit String Literalen arbeitet funktioniert natürlich ohne dynamischen Speicher-Allokation. Jedoch schien mir MyString mehr ein Versuch einer String-Klasse und bei einer einigermassen sinnvollen und flexiblen String-Klasse wird typischerweise in irgendeiner Form dynamischer Speicher benötigt.

@Mister004:
Achtung, new benötigt immer ein delete, new[] immer ein delete[] und malloc() und Konsorte immer ein free() - mischen ist falsch und ein Problem!

Ausserdem sollst Du die Grosse Drei bei deiner String-Klasse beachten - oder Zuweisen und Kopieren verbieten.

pyhax

theta schrieb:

@pyhax: Naja, das kleine Bsp. welches mit String Literalen arbeitet funktioniert natürlich ohne dynamischen Speicher-Allokation. Jedoch schien mir MyString mehr ein Versuch einer String-Klasse und bei einer einigermassen sinnvollen und flexiblen String-Klasse wird typischerweise in irgendeiner Form dynamischer Speicher benötigt.

Ja ... aber doch nicht in der main! In der Klasse selber, ja.

theta

pyhax schrieb:

theta schrieb:

@pyhax: Naja, das kleine Bsp. welches mit String Literalen arbeitet funktioniert natürlich ohne dynamischen Speicher-Allokation. Jedoch schien mir MyString mehr ein Versuch einer String-Klasse und bei einer einigermassen sinnvollen und flexiblen String-Klasse wird typischerweise in irgendeiner Form dynamischer Speicher benötigt.

Ja ... aber doch nicht in der main! In der Klasse selber, ja.

Ah.. i see...