#include <iostream>
#include <string>

struct Data {
	std::string text;
};

void doSomething(const Data& data) {
	std::cout << data.text << std::endl;
}

int main() {
	doSomething(Data{"test"});
}

Nur leider funktioniert dies nicht, der Compiler (MSVC 10) meckert, dass da ganz viele Syntaxfehler in Zeile 13 sind. Gibt es eine andere Möglichkeit, den Konstruktor wegzulassen?

Sowas müssteste dann schon machen

#include <iostream>
#include <string>

struct Data {
    Data( const char* str ) : text( str ) {}
    std::string text;
};

void doSomething(const Data& data) {
    std::cout << data.text << std::endl;
}

int main() {
    doSomething(Data("test"));
}

In Zeile 14 hab ich dann übrigens deine geschweiften Klammern durch runde ersetzt.

void doSomething(const Data& data);

void doSomething(const std::string& str) {
  Data d;
  d.str = str;
  doSomething(d);
}

Wenn du generell häufig ein data aus einem string machst, eine Konvertierungsfunktion:

Data strToData(std::string const& str)
{
  Data d;
  d.str = str;
  return d;
}

/* ... */
void somewhere_else()
{
  doSomething(strToData("Meh"));
}

struct BaseData {
    int int1;
    std::string text;
}

struct OtherData {
    BaseData base;
    int int2;
}
// usw.

Jetzt kann ich zwar ein OtherData Objekt so ohne Konstruktor initialisieren:

OtherData data = {1, "test", 2};

Jedoch muss ich, wenn ich eine Funktion die ein OtherData Objekt benötigt zehn mal aufrufe zehn OtherData Objekte erstellen, da man immer nur einmal ein Objekt so schön initialisieren kann. Also etwa so:

void foo(const OtherData& data) {
//...
} 

int main() {
    OtherData data1 = {1, "test", 2};
    foo(data1);
    OtherData data2 = {2, "test", 2};
    foo(data2);
    OtherData data3 = {3, "test", 2};
    foo(data3);
}

Das ganze wird zwar alles vom Compiler optimiert, jedoch sieht es hässlich aus und ist eine Menge schreibarbeit.
Die einzige Alternative scheint also ein Konstrukor zu sein, jedoch schreibe ich mich dumm und dämlich, wenn ich z.B. 10 structs habe, die ein OtherData Objekt besitzen, und jeder Konstruktor davon 15 bis 20 Argumente annehmen muss.
Gibt es dafür jetzt also eine schreibärmere und elegantere Lösung?

jeder Konstruktor davon 15 bis 20 Argumente annehmen muss.
Gibt es dafür jetzt also eine schreibärmere und elegantere Lösung?

Das ist wahnsinn. Warum gibst du dem BaseData struct nicht einen Konstruktor? Du wirst dann doch eh BaseData's rumreichen und ggf. modifizieren, aber nicht jedesmal alle Werte einzeln neu zusammenstückeln oder?