wie übergebe ich structs an Funktionen, die in einer headerdatei stehen? Ich versuche mal darzustellen;

main.cpp

#include "header.h"

struct Eins
{
   //
};

struct Zwei
{
    //
};

int main()
{
    Eins eins;
    Zwei zwei;

    func(eins, zwei);
}

header.h

void func(Eins, Zwei);

header.cpp

void func(Eins, Zwei)
{
    //
}

Habe es jetzt einfach in den Foreneditor geschrieben, hoffe ist trotzdem kein Unsinn. Jedenfalls kommt die Meldung, Eins und Zwei sind nicht deklariert. Müsste ich die structs in einen eigenen Header schreiben und jeweils einbinden oder kann ich das auch anders machen?

wenn auch immer Du einen Typ oder einen anderen Bezeichner verwendest, muß dieser VORHER bekannt sein. Nicht hinterher.

Du solltest also die Deklaration von Eins und Zwei in die Datei header.h VOR dem Prototypen von func verschieben.

VG Martin
Innerhalb einer Klassendeklaration, darf er auch hinterher stehen. Das ist aber die einzige Ausnahme.

Eigentlich möchte ich ein, zwei spezielle Funktionen haben, die sonst im Hauptprogramm nicht direkt benötigt werden, falls aber doch, ich sie einfach fix über einen Header einbinde.

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

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.

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.

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".

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&) ?

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?

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?

1. 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?