Klasseninstanz über std::vector erzeugen

[theAnfänger77]

Für die Vollständigkeit:

Möglichkeit 1:
punkt.cpp sieht so aus:

#include "punkt.h"
#include <iostream>

punkt::punkt()
{
    setPunkt();
}

void punkt::setPunkt()
{
    std::cout<<"X Koordinate: ";
    std::cin>>this->x;
    std::cout<<"Y Koordinate: ";
    std::cin>>this->y;
}

void punkt::getPunkt()
{
    std::cout<<this->x<<" ";
    std::cout<<this->y<<std::endl;
}

Möglichkeit 2:
punkt.cpp sieht so aus:

#include "punkt.h"
#include <iostream>

punkt::punkt()
{
    std::cout<<"X Koordinate: ";
    std::cin>>this->x;
    std::cout<<"Y Koordinate: ";
    std::cin>>this->y;
}


void punkt::getPunkt()
{
    std::cout<<this->x<<" ";
    std::cout<<this->y<<std::endl;
}

wobei man hier "setPunkt" nicht mehr braucht

[wob]

Ähm. setPunkt sollte nicht einlesen und ausgeben. Ansonsten ist doch die Funktionalität der Punkt-Klasse sehr eingeschränkt. Ich würde mit eher 2 Funktionen setX und setY vorstellen, die jeweils einen Parameter haben und den Wert dann setzen. "Einlesen von cin" ist nicht die Kernkompetenz von Punkt!

[theAnfänger77]

So ist es natürlich am elegantesten

void punkt::setx(int x)
{
    this->mx = x;
}

void punkt::sety(int y)
{
    this->my = y;
}

[Swordfish]

So ist es natürlich am elogantesten

struct punkt
{
    int x;
    int y;
};

[It0101]

@theAnfänger77 sagte in Klasseninstanz über std::vector erzeugen:

So ist es natürlich am elegantesten

void punkt::setx(int x)
{
    this->mx = x;
}

void punkt::sety(int y)
{
    this->my = y;
}

Schon besser. Das "this->" kannst du dir übrigens sparen.
Zu Übungszwecken könntest du noch Operatoren defininieren, damit man mit den Punkten auch rechnen kann.
Die Rule-Of-Five wäre hier auch sinnvoll angewendet, denn mit so einer Punkt-Klasse will man üblicherweise alles mögliche machen.

Eine Funktion zur Berechnung der Distanz zweier Punkte wäre auch noch sinnvoll.

[wob]

@It0101 sagte in Klasseninstanz über std::vector erzeugen:

Zu Übungszwecken könntest du noch Operatoren defininieren, damit man mit den Punkten auch rechnen kann.

Ich kann mir gerade keinen sinnvollen Usecase vorstellen, bei dem man 2 Punkte addieren oder multiplizieren können sollte. An was hattest du konkret gedacht? Ich finde, dass auch Übungszwecke zumindest halbwegs sinnvoll sein sollten.

Die Rule-Of-Five wäre hier auch sinnvoll angewendet, denn mit so einer Punkt-Klasse will man üblicherweise alles mögliche machen.

Rule of five für Punkte?! Was soll denn deine Punktklasse alles machen? Ist doch eher ein typisches Beispiel für Rule of Zero!

Eine Funktion zur Berechnung der Distanz zweier Punkte wäre auch noch sinnvoll.

Aber sicher nicht innerhalb der Punkt-Klasse. Fängt schon damit an, dass man erstmal "Distanz" definieren müsste (welche Metrik?).

[Th69]

Was soll die Rule-Of-Five (s.a. The rule of three/five/zero) hier bringen? Weder eigener Destruktor, Kopierkonstruktor oder Zuweisungsoperator sind hier sinnvoll...

[It0101]

@Th69
Es ist eine Übungsaufgabe. Jetzt macht euch mal nicht ins Hemd. Da will man mal jemanden motivieren, Dinge anzuwenden, die er sonst vielleicht nicht anwendet und ihr redet das schlecht. Man man... eure pädagogischen Fähigkeiten sind ungefähr das was man bekommt, wenn man 1 durch unendlich teilt...

@wob: Punkte addieren macht keinen Sinn? Vector-Rechnung hattest du aber in der Schule oder?

[wob]

@It0101 sagte in Klasseninstanz über std::vector erzeugen:

@wob: Punkte addieren macht keinen Sinn? Vector-Rechnung hattest du aber in der Schule oder?

Ja, ich schon. Du auch? Aber hast du da Punkte addiert? Ich nicht. Ich habe dort Vektoren addiert.

[Th69]

@It0101: Klar, wir packen jedes Pattern in eine Übungsaufgabe!???

[It0101]

@Th69 sagte in Klasseninstanz über std::vector erzeugen:

@It0101: Klar, wir packen jedes Pattern in eine Übungsaufgabe!???

Wir nicht. Aber Anfängern schadet es nicht. Zumal wir hier nicht vom einem aufgezwungenen Parameter-Pack oder einem Funktionstemplate reden, sondern von etwas was man im Grunde häufig braucht und wo etwas Übung nicht schadet.

[It0101]

Liebe C++-Lernende. Ihr wendet bitte in Zukunft C++-Programmiertechniken nur noch dann an, wenn die Übungsaufgabe es explizit erfordert oder es von @Th69 oder @wob authorisiert wurde. Auf gar keinen Fall werdet ihr euch außerhalb der exakt passenden Übungsaufgabe mit der Rule-of-Five und anderen Pattern beschäftigen, die zur täglichen Routine gehören sollten. Ausnahmen gibts keine.

[wob]

@It0101 sagte in Klasseninstanz über std::vector erzeugen:

Ihr wendet bitte in Zukunft C++-Programmiertechniken nur noch dann an, wenn die Übungsaufgabe es explizit erfordert oder es von @Th69 oder @wob authorisiert [sic!] wurde. Auf gar keinen Fall werdet ihr euch außerhalb der exakt passenden Übungsaufgabe mit der Rule-of-Five und anderen Pattern beschäftigen, die zur täglichen Routine gehören sollten. Ausnahmen gibts keine.

Selten so einen Quatsch gelesen!

@It0101 sagte in Klasseninstanz über std::vector erzeugen:

Aber Anfängern schadet es nicht.

Darüber kann man streiten. Wenn man Anfängern erzählt, dass sie Operatorüberladung auch für ungefähr passende Dinge anwenden sollen und sie die Rule of 5 dort einsetzen lässt, wo sie überhaupt nicht passt, dann kann das durchaus kontraproduktiv sein, weil es nachträglich unter anderem wesentlich schwieriger wird beizubringen, dass eine Klasse nur eine Sache tun soll und nicht hunderte andere Dinge mit übernehmen soll.

Niemand will verbieten, sich über diese Dinge zu informieren bzw. sich damit zu beschäftigen.

[Swordfish]

@It0101 sagte in Klasseninstanz über std::vector erzeugen:

[...] sondern von etwas [Rule of 5] was man im Grunde häufig braucht [...]

So ein Quatsch. Wenn bei Dir das Anwenden der Rule of 5 zur täglichen Routine gehört machst Du irgendwas falsch.

[It0101]

@Swordfish sagte in Klasseninstanz über std::vector erzeugen:

@It0101 sagte in Klasseninstanz über std::vector erzeugen:

[...] sondern von etwas [Rule of 5] was man im Grunde häufig braucht [...]

So ein Quatsch. Wenn bei Dir das Anwenden der Rule of 5 zur täglichen Routine gehört machst Du irgendwas falsch.

Gut häufig ist übertrieben, geb ich zu. Aber jeder sollte sie beherrschen. Mein Ziel ist immer die häufige Verwendung von "= delete"

[Abe]

@It0101 Was macht delete eigentlich ?
bei

char *ptr = {'A','B','C','D'}; // speicher für 4 char's reserviert 
delete ptr ;   //speicher leer?
ptr = NULL; //unvorhergesehene Ereignisse vermeiden  

bin ich da so jetzt richtig ?

[Swordfish]

Das ist nicht kosher. Du darfst delete nur Zeiger füttern, die von new kommen und delete[] Zeiger von new[]. Und natürlich nullptr.

[Abe]

ja hab ich eben auch gerade gemerkt . :'D
Habe auf absenden gedrückt bevor mir eingefallen ist das ich auch einfach versuchen kann.

[It0101]

Ich meinte die andere Sorte von delete

Die Sorte hier, die man braucht wenn man davon überzeugt ist, dass man die Instanzen einer Klasse niemals kopieren oder moven will

public MyClass
{
    MyClass();
    ~MyClass() = default;
    MyClass( const MyClass & ) = delete;
    MyClass &operator=( const MyClass & ) = delete;
    MyClass( MyClass && ) = delete;
     MyClass &operator=( MyClass && ) = delete;
};

[theAnfänger77]

Noch zu der Übungsaufgabe von It0101:
Ich fand das gut und habe es zur Übung mal in einem Fenster realisiert.
Vielleicht mal für die Vollständigkeit hier mein Lösungsvirschlag:

Das ist jetzt nut die mainwindow.cpp Datei:

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <math.h>

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    connect(ui->pushButton, SIGNAL(clicked()), SLOT(pbClicked()));
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::pbClicked()
{
    P1X = ui->lineEdit->text();
    P1Y = ui->lineEdit_2->text();
    P2X = ui->lineEdit_3->text();
    P2Y = ui->lineEdit_4->text();

    fP1X = P1X.toFloat();
    fP1Y = P1Y.toFloat();
    fP2X = P2X.toFloat();
    fP2Y = P2Y.toFloat();

    float fAbstand = sqrt(pow((fP2X-fP1X),2)+pow((fP2Y-fP1Y),2));
    ui->label_4->setNum(fAbstand);
}