arrays überladen

SeppJ

alterbro schrieb:

ja, das heisst anstatt in eine funktion zu springen, wird der code direkt in den code gepackt.

Eben nicht. Es geht um Linkage und ODR.

Sone

Was ist so schlimm daran eine Schleife zu schreiben?
Sonst kannst du bei bspw. Sequentiellen STL-Containern auch

Container c(10, 9);

schreiben, und es gibt übrigens auch STL-Algorithmen dazu.

inline vor eine Funktion packen tut man heute, um die Funktion im Header definieren zu können (sonst beschwert sich der Linker, dass eine Funktion in mehreren Übersetzungseinheiten (wenn man denn mehrere hat) definiert wurde, was ja klar und deutlich gegen die ODR (One-Definition-Rule) spricht).

TyRoXx

alterbro schrieb:

jetzt hab ich mich gefragt ob das auch mit arrays funktioniert, um mir die schleifen zu ersparen.

Das geht mit einem richtigen C++-Array ganz leicht:

#include <array>

int main()
{
	std::array<int, 123> arr;
	arr.fill(9);
}

alterbro

tyrox:

Danke

sone:

Eine schleife weniger= 0.5 sekunden gespart.

in einem grossen projekt macht das was aus.

SeppJ

alterbro schrieb:

sone:

Eine schleife weniger= 0.5 sekunden gespart.

in einem grossen projekt macht das was aus.

Denk mal darüber nach, was wohl im Computer passiert, wenn da keine Schleife zu sehen ist.

edit: Tipp: Der genauen Formulierung meiner Aufforderung kann man schon die Lösung entnehmen.

Jedenfalls hast du noch viel zu lernen, bevor du Performanceargumente bringen kannst, sonst wird das eher lustig (für andere).

pyhax

TyRoXx schrieb:

alterbro schrieb:

jetzt hab ich mich gefragt ob das auch mit arrays funktioniert, um mir die schleifen zu ersparen.

Das geht mit einem richtigen C++-Array ganz leicht:
#include <array>

int main()
{
	std::array<int, 123> arr;
	arr.fill(9);
}

Das geht auch mit einem "normalen" C++ Array ganz leicht:

#include <algorithm>

int main()
{
       int arr[123];
       std::fill(arr, arr + 123, 9);
}

Nexus

pyhax schrieb:

Das geht auch mit einem "normalen" C++ Array ganz leicht

Du meinst C-Array

Und ein Nachteil deiner Variante ist offensichtlich: Du gibst die Grösse nochmals an. Wenn man dann etwas mehr Funktionalität braucht, gehts erst recht nicht mehr so leicht (z.B. Kopieren, Zuweisen, Funktionsübergabe und -rückgabe). Ausserdem hat man keine Debug-Features wie Index- und Iteratorchecks, und die STL-Interfacekonformität ist auch nicht gegeben.

std::array sollte man immer über rohe Arrays bevorzugen, für letztere spricht in C++ eigentlich nichts mehr. Leider werden sie doch noch oft verwendet.

Sone

Nexus schrieb:

std::array sollte man immer über rohe Arrays bevorzugen, für letztere spricht in C++ eigentlich nichts mehr. Leider werden sie doch noch oft verwendet.

Speed
Außerdem kann man die Größe eines (echten) C-Style Arrays ganz einfach bestimmen, und ich sehe auch überhaupt nicht ein, wozu man in kleinen Situationen gleich ein STL-Container braucht, wenn es auch ein C-Style Array tut.

Ethon

Es gibt keinen Performaceunterschied zwischen normalen Arrays und std::array.

Nexus

Sone schrieb:

Speed

Genau wegen solcher Irrtümer werden immer noch Arrays verwendet. Die Hälfte aller C++-Mythen existiert ohnehin nur wegen Unwissen im Bezug auf Performance, ist also nicht speziell verwunderlich.

Sag mir, warum std::array langsamer als ein C-Array sein sollte. Im Release-Modus natürlich.

Sone schrieb:

Außerdem kann man die Größe eines (echten) C-Style Arrays ganz einfach bestimmen

Ja, ganz einfach.

sizeof(array)/sizeof(array[0])

Kommt es zum "array-to-pointer decay", hat man schöne Bugs. Übrigens ist diese Konvertierung auch so ein implizites "Feature", das man mit std::array nicht hat.

Sone schrieb:

und ich sehe auch überhaupt nicht ein, wozu man in kleinen Situationen gleich ein STL-Container braucht, wenn es auch ein C-Style Array tut.

Umso besser, dass ich im letzten Post genügend Gründe genannt habe

_matze

Nexus schrieb:

Ja, ganz einfach.
sizeof(array)/sizeof(array[0])
Kommt es zum "array-to-pointer decay", hat man schöne Bugs. Übrigens ist diese Konvertierung auch so ein implizites "Feature", das man mit std::array nicht hat.

Ich kann dir nur zustimmen. Genau darüber bin ich letztens wieder gestolpert. Unter extremem Zeitdruck eine RS232-Kommunikations-Funktion zusammengecopypastet, dabei einige lokale Variablen zu Parametern gemacht und nicht die Längenbestimmung angepasst - und mich dann gewundert, dass immer nur 4 Bytes geschrieben werden. Leute, nehmt einfach einen vernünftigen Container. Ihr erspart euch eventuell einiges an Ärger. Wenn ihr dann meint, dass der zu langsam ist und ihr ein echtes Zeitproblem habt (nicht, weil optimieren cool ist), dann könnt ihr es immer noch testweise umbauen und messen, ob es irgendwas bringt.

Ethon

Da sowohl normale Arrays als auch std::array eine konstante Größe erfordern, ist es total egal wie gut man im Code die Größe bestimmen kann, da sie sowieso bekannt sein muss. "Magic numbers" als Arraygrößen sind sowieso Krebs und sollten durch etwas mit Namen ersetzt werdenn.

Kellerautomat

Der einzige Nachteil, den ich bei std::array kenne, ist, dass man die Größe immer angeben muss. Das kann bei einer Initialisierung unpraktisch sein. Z.B.

int data[] = { 1, 2, 3, 4, 5 }; // Größe deduziert
arra<int, 5> = { 1, 2, 3, 4, 5 }; // Größe muss angegeben werden

Vielleicht bietet C++1y ja eine Lösung hierfür.

Shade Of Mine

Ethon schrieb:

Da sowohl normale Arrays als auch std::array eine konstante Größe erfordern, ist es total egal wie gut man im Code die Größe bestimmen kann, da sie sowieso bekannt sein muss.

Das ist aber leider nicht gegeben. Sobald ich das Array naemlich an eine Funktion uebergebe verliere ich idR diese Information. Ich kann natuerlich immer aufpassen die korrekte Groesse immer mitzugeben - aber bei std::array ist sie immer da egal was passiert.

std::array ist in jeder einzelnen Situation besser (bzw. gleich gut) als ein plain array. Jeder einzelnen.

PS:
@Kellerautomat:
du kannst dir ein make_array bauen mit variadic templates und auto als typ verwenden.

PPS:
kann mir wer erklaeren warum folgendes funktioniert

template <typename Head, typename... Tail>
std::array<Head,1+sizeof...(Tail)> make_array(Head head, Tail const&... tail) {
    std::array<Head,1+sizeof...(Tail)> a={ head, tail... };
    return a;
}

aber folgendes nicht?

template <typename Head, typename... Tail>
std::array<Head,1+sizeof...(Tail)> make_array(Head head, Tail const&... tail) {
    return std::array<Head,1+sizeof...(Tail)> ({ head, tail... });
}

Nexus

Kellerautomat schrieb:

Vielleicht bietet C++1y ja eine Lösung hierfür.

Oder C++11 mit einem selbstgeschriebenen Variadic Function Template make_array() . Kenne mich leider mit Variadic Templates nicht aus.

Shade Of Mine

Mein Vorschlag fuer make_array:

template <typename Head, typename... Tail>
std::array<Head, 1+sizeof...(Tail)> make_array(Head&& head, Tail&&... tail) {
    return std::array<Head, 1+sizeof...(Tail)> { std::forward<Head>(head), std::forward<Tail>(tail)... };
}

Verbesserungsvorschlaege willkommen
Bin mit den neuen features noch nicht so per du

TyRoXx

Funktioniert mit Clang 3.0:

#include <array>

template <class First, class ...Rest>
auto make_array(First && first, Rest && ...rest)
	-> std::array<First, 1 + sizeof...(Rest)>
{
	return
	{
		std::forward<First>(first),
		std::forward<Rest>(rest)...
	};
}

int main()
{
	const auto a = make_array(1, 2, 3, 4);
	static_assert(std::is_same<const std::array<int, 4>, decltype(a)>::value,
		"make_array liefert einen unerwarteten Typ");
}

Ist das korrekt und optimal so?

Ethon

Shade Of Mine schrieb:

Ethon schrieb:

Da sowohl normale Arrays als auch std::array eine konstante Größe erfordern, ist es total egal wie gut man im Code die Größe bestimmen kann, da sie sowieso bekannt sein muss.

Das ist aber leider nicht gegeben. Sobald ich das Array naemlich an eine Funktion uebergebe verliere ich idR diese Information. Ich kann natuerlich immer aufpassen die korrekte Groesse immer mitzugeben - aber bei std::array ist sie immer da egal was passiert.

std::array ist in jeder einzelnen Situation besser (bzw. gleich gut) als ein plain array. Jeder einzelnen.

Nö, bei std::array musst du die Information doch auch explizit mitgeben.

template<std::size_t Size>
void i_like_ints(std::array<int, Size>& ints) {}

_matze

Ethon schrieb:

Nö, bei std::array musst du die Information doch auch explizit mitgeben.

Bei einem plain array musst du das nicht.

Shade Of Mine

Ethon schrieb:

template<std::size_t Size>
void i_like_ints(std::array<int, Size>& ints) {}

Keine Ahnung warum man so ein template haben will, aber bitte - funktioniert einwandfrei:

auto a=make_array(1,2,3,4,5);
i_like_ints(a);