struct an "header"-Funktion übergeben

Du bist jetzt seit sechs Jahren Anfänger. So langsam solltest du diese trivialen Dinge doch beherrschen.

Hi,
kannst es entweder so machen:
test1.h

struct Teststruct1
{
	std::string wert1_struct1;
};

class Tester
{
private:
	Teststruct1 test;

public:
	void funktion1(Teststruct1 test2);
};

das dein struct vor deiner funktion oder klasse definiert ist.
(hier ist jetzt nat. nur der header gezeigt, rest sollte ja klar sein )

oder machst wie schon gesagt einfach eine eigene header-datei für deine structs, in etwa so:

main.cpp

Teststruct1 teststruct1;
	teststruct1.wert1_struct1 = "Hallo Welt";
	std::cout << teststruct1.wert1_struct1 << std::endl;

	Tester testObj;
	testObj.funktion1(teststruct1);

test1.h

#include "struct.h"

class Tester
{
private:
	Teststruct1 test;

public:
	void funktion1(Teststruct1 test2);
};

test1.cpp

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

void Tester::funktion1( Teststruct1 test2 )
{
	std::cout << test2.wert1_struct1 << std::endl;
}

struct.h

#include <string>

struct Teststruct1
{
	std::string wert1_struct1;
};

hoff konnte etwas helfen
lg

DirkB

lemon03 schrieb:

Bin mir nicht sicher, ob ich richtig verstanden habe, das läuft doch aber dann auf eigene Header für die structs hinaus? Ich will ja nicht die structs in diesem funktionsheader haben.

Nein, sie müssen nur vorher definiert sein, bzw. die Funktionsdeklaration nach der struct-Definition.

zeropage

Danke für die Antworten, aber

manni66 schrieb:

Du bist jetzt seit sechs Jahren Anfänger. So langsam solltest du diese trivialen Dinge doch beherrschen.

nun bin ich erst mal wieder etwas unsicher. Ich werde dann wohl meine structs und die dazugehörigen Funktionen in eigene Header packen. Hat evtl auch den Vorteil, das ich bei anderen Dateiformate nur andere Header schreiben muss, die main aber so lassen kann. Und kann andere Funktionen, die ja eigentlich nicht in die Nähe der structs gehören, dann auslagern.

Im Übrigen bin ich zwar seit 6 Jahren angemeldet, code aber einigermaßen ernsthaft erst seit einem Jahr. Außerdem kann man in einem Monat 60 Stunden üben, oder in 5 Jahren.

zeropage

Ok - ging alles gut -

zeropage

Zur Sicherheit würde ich aber trotzdem gerne nachfragen, ob das wieder etwas merkwürdig ist. Analog zu meiner ersten Darstellung habe ich es jetzt so gemacht;

struct.h

struct Eins
{
   //
};

//

struct.cpp

#include "struct.h"

Eins eins;

//

func.h

#include "struct.h"

void func(Eins);

func.cpp

#include "func.h"

void func(Eins eins)
{
    //
}

main.cpp

#include "struct.h"
#include "func.h"

int main()
{

    Eins eins;

    func(eins);
}

Die Funktion func ist zB nur für eine eventuelle Ausgabe zuständig. Benötigt wird sie für das Programm eigentlich nicht. Wollte sie deshalb irgendwie "auslagern".

1. Sind das die vollständigen Dateien? Dann fehlen in deinen Header-Dateien die Include-Guards.

2. Wofür soll die Variable Eins eins in struct.cpp gut sein? (übrigens ein beschissener Name - ich hoffe, dass du den nur für uns hier so geändert hast)

3. Eine Frage zu func.h/cpp: Deine Signatur ist void func(Eins); . Wie groß ist denn deine struct Eins? Willst du das wirklich per Value übergeben? Wenn nicht: übergib eine const&. Und wenn du im Header nur Referenzen oder Pointer hast, musst du nicht unbedingt den Header includen, dann reicht auch schon eine Vorwärts-Deklaration.

4. Wenn func nur der Ausgabe diesen soll, warum überlädst du dann nicht einfach den ostream& operator<<(ostream&, const Eins&) ?

zeropage

1 - Nö

2 - Natürlich

Nur soll der Quark ja immer auf ein Minimum beschränkt werden. Minimalistischer geht es wohl nicht mehr?

Rest kommt evtl später ...
später ...

4 - weil func so aussieht?

#include "output.h"
#include <iostream>
#include <fstream>
#include <iomanip>

void write_dataLog(std::string file_,
                   std::vector <unsigned char> const& bmp_data,
                   Head head, Info info, ColTable colTbl)
{
    const std::string file_name = file_ + ".bmp";
    std::ofstream file(file_name + ".txt");
    file << "_File: " << file_name << '\n';
    std::array <std::size_t, head.Size> hbfSize = { 2,4,4,4 };
    std::array <std::size_t, info.Size> ibfSize = { 4,4,4,2,2,4,4,4,4,4,4 };

    //Kopf und Eigenschaften
    file << '\n' << '\n';
    file << "_Kopf_" << '\n' << '\n';
    for (auto i=0; i<head.Size; i++)
    {
        file << std::left;
        file << '#' << std::setw(4) << std::dec << std::get<0>(head.bType.at(i));
        file << std::setw(19) << std::left << std::get<1>(head.bType.at(i));
        for (std::size_t j=0; j<hbfSize.at(i); j++)
        {
            file << std::right;
            file << std::setw(2) << std::setfill('0') << std::hex << int(bmp_data.at(i+j)) << ' ';
        }
        file << std::setfill(' ') << std::setw(3 + 6 * (4/hbfSize.at(i))) << std::dec << head.data.at(i) << '\n'; //Dezimalwert
    }
    file << '\n' << '\n';
    file << "_Eigenschaften_" << '\n' << '\n';
    for (auto i=0; i<info.Size; i++)
    {
        file << std::left;
        file << '#' << std::setw(4) << std::dec << std::get<0>(info.bType.at(i));
        file << std::setw(19) << std::left << std::get<1>(info.bType.at(i));
        for (std::size_t j=0; j<ibfSize.at(i); j++)
        {
            file << std::right;
            file << std::setw(2) << std::setfill('0') << std::hex << int(bmp_data.at(i+j)) << ' ';
        }
        file << std::setfill(' ') << std::setw(3 + 6 * (4/ibfSize.at(i))) << std::dec << info.data.at(i) << '\n'; //Dezimalwert
    }

    // Farbmasken  //wird zur Zeit erstmal abgebrochen
    int biCompression = info.data.at(5);
    if (biCompression != 0)
    {
        file << '\n'
             << "biCompression = " << biCompression << '\n'
             << "Bilddaten sind kodiert\nkann im Moment nicht verarbeitet werden" << '\n';
        file.close();
    }

    // Farbtabelle
    file << '\n' << '\n';
    file << "_Farbtabelle_ ";
    if (colTbl.is_ )
    {
        file << "     Size: " << colTbl.size_ << '\n' << '\n';
        file << std::setw(9) << "B" << std::setw(3) << "G" << std::setw(3) << "R";
        file << std::setw(14) << "B" << std::setw(5) << "G" << std::setw(5) << "R";
        file << '\n' << '\n';
        std::size_t offset = 54;
        for (auto i=0; i<colTbl.size_; i++)
        {
            file << std::left;
            file << '#' << std::setw(6) << std::setfill(' ') << std::dec << offset;
            file << std::right << std::hex;
            file << std::setw(2) << std::setfill('0') << int(std::get <0> (colTbl.data.at(i))) << ' '
                 << std::setw(2) << std::setfill('0') << int(std::get <1> (colTbl.data.at(i))) << ' '
                 << std::setw(2) << std::setfill('0') << int(std::get <2> (colTbl.data.at(i))) << ' '
                 << std::setw(2) << std::setfill('0') << int(std::get <3> (colTbl.data.at(i))) << ' ';
            file << std::dec << "      "; //Dezimalwerte
            file << std::setw(4) << std::setfill(' ') << int(std::get <0> (colTbl.data.at(i))) << ' '
                 << std::setw(4) << std::setfill(' ') << int(std::get <1> (colTbl.data.at(i))) << ' '
                 << std::setw(4) << std::setfill(' ') << int(std::get <2> (colTbl.data.at(i))) << ' ';

            file << '\n';
            offset += 4;
        }
    }
    else
    {
        file << ": keine" << '\n';
    }
    file.close();

    std::cout << file_name << ".log wurde erstellt" << '\n';
}

Habe absolut keinen Plan, wie ich das mit ostream& operator<<(ostream&, const Eins&)? machen soll?

Braunstein

Schau doch mal im Magazin nach.
https://www.c-plusplus.net/forum/232010
Punkt 3.4

lemon03 schrieb:

Nur soll der Quark ja immer auf ein Minimum beschränkt werden. Minimalistischer geht es wohl nicht mehr?

Auf ein nachvollziehbares Minimum. Ich war, als du geschrieben hast, dass func(Eins) der Ausgabe diene, natürlich davon ausgegangen, dass func nur Eins irgendwie ausgibt. Du hast aber viel mehr Parameter und nutzt die Eins-Variable nur als Hilfe zur Ausgabe von bmp_data, daher ergibt mein Hinweis auf operator<< natürlich so erstmal wenig Sinn.

4 - weil func so aussieht?

Zu func hätte ich diverse Fragen/Anmerkungen.
0. ganz schön lang... allerdings nur Ausgabe. Statt file vielleicht besser den ostream& übergeben, in den geschrieben werden soll und das Öffnen/Schließen/Errorchecking separat machen?

std::ofstream file(file_name + ".txt"); ... std::cout << file_name << ".log wurde erstellt" << '\n'; ist inkonsistent. Variable log_file_name einführen? Und sollte die Variable file_ vielleicht besser basename heißen?
2. Check ob Datei auch is_open ist?
3. hbfSize / ibfSize: Ein Kommentar täte gut. Was sind das für magische Zahlen? Gehören diese Konstanten nicht eher in die Head- bzw Info-Klasse?
4. Du verwendest viel std::get<0,1,...> im Code, obwohl der nicht generisch aussieht. Warum? Könnte man nicht anständige Namen verwenden?
5. Im Fall biCompression != 0 machst du file.close() und danach wird munter weiter in file geschrieben und file nochmal geschlossen.
6. (ich wiederhole mich) Warum sind file_, head, info, colTbl nicht per const& übergeben?

struct an &quot;header&quot;-Funktion übergeben

struct an "header"-Funktion übergeben