Meinung zu Programm

Swordfish

#include <stddef.h>
#include <stdbool.h>
#include <stdio.h>

#define sizeof_array( x ) (sizeof( x ) / sizeof( *x ) )

void swap( long * a, long *b )
{
	long tmp = *a;
	*a = *b;
	*b = tmp;
}

void sort( long * container, size_t size )
{
	bool sorted;
	size_t i;
	do {
		sorted = true;
		for( i = 0; i < size - 1; ++i )
			if( container[ i ] > container[ i + 1 ] ) {
				sorted = false;
				swap( container + i, container + i + 1 );
			}
	} while( !sorted );
}

int main( void )
{
	long MyContainer[] = { 13, 23, 0, 4, 6, 1, 5, 50, 10, 10, 4, 3, 10 };
	size_t i;

	for( i = 0; i < sizeof_array( MyContainer ); ++i )
		printf( "%li ", MyContainer[ i ] );
	putchar( '\n' );

	sort( MyContainer, sizeof_array( MyContainer ) );

	for( i = 0; i < sizeof_array( MyContainer ); ++i )
		printf( "%li ", MyContainer[ i ] );
	putchar( '\n' );
}

Ok, danke gibt es einen speziellen Unterschied zwischen unsigned long und size_t?

sorter3 schrieb:

Könnte sich das mal jemand anschauen und mir sagen ob ich noch einen Fehler drin hab, oder ob man etwas besser machen könnte?

Klar.

Das hier ist Grütze:

`

for(i=0;i<=12;i++)

`

Wenn du schon Konstanten definierst, dann solltest du sie auch anwenden:

`

for(i=0;i<SIZE;i++)

`

und wenn Variablen im Spiel sind, dann prüft man gegen die Variablen und
nicht gegen dubiose im Code fest definierte Werte:
`

char n[10];

....

for(i=0;i<=n;i++)

`

Bei deinem Murks müssen an zwei verschiedenen Orte Werte angepasst werden, damit das Programm wieder das tut, was es soll.
Also bei SIZE und in der for Schleife.

Das gleiche Problem existiert hier:

sorting(MyContainer,13);

Was machst du, wenn du irgendwann nach x Wochen Arbeit für MyContainer eine andere Größe festlegen möchtest?
Dann ist deine 13 wieder Mist.

Also entweder baust du hier wieder die Konstante SIZE ein, oder du prüfst die Länge per sizeof() Operator zur Laufzeit.
Letzteres ist wichtig, wenn das Array eine dynamische Größe haben soll, die sich zur Laufzeit ändern kann.

Deine selbstgebastelte Längenprüfung mit check() ist daher auch völlig überflüssig, wenn du es von Anhieb wie oben geschrieben richtig machen würdest.

Und zum Sortieren gibt es den Quicksort Algorithmus, schau dir den mal an und implementiere ihn.

sorter3 schrieb:

Ok, danke gibt es einen speziellen Unterschied zwischen unsigned long und size_t?

size_t ermöglicht die Angabe von Größen für das größte adressierbare Objekt im System.

Das kann auf 64-Bit-Systemen auch 64-Bit groß sein.
Auf 16-Bit-Systemen auch 16-Bit.

unsigned long ist meist 32-Bit oder größer (z.B. bei 64-Bit Linux)

Daher ist die Aussage von n3 Mumpitz.

Swordfish

sorter3 schrieb:

Ok, danke gibt es einen speziellen Unterschied zwischen unsigned long und size_t?

Der Standard garantiert, daß size_t groß genug für jede mögliche Objektgröße ist. Für unsigned long ist das nicht garantiert.

Rastawasta schrieb:

Also entweder baust du hier wieder die Konstante SIZE ein, oder du prüfst die Länge per sizeof() Operator zur Laufzeit.
Letzteres ist wichtig, wenn das Array eine dynamische Größe haben soll, die sich zur Laufzeit ändern kann.

sizeof wird nicht zur runtime ausgewertet, sondern zur compiletime. Für irgendwas mit dynamischer Größe wirst mit sizeof nicht glücklich.

@Rastawasta
Stimmt, SIZE habe ich am Schluss noch eingefügt und vergessen zu benutzen.
Check ist keine Längenprüfung.
Ich verstehe auch nicht ganz wie sort von Swordfish funktioniert.

void sort( long * container, size_t size )
{
    bool sorted;
    size_t i;
    do {
        sorted = true;
        for( i = 0; i < size - 1; ++i )
            if( container[ i ] > container[ i + 1 ] ) {
                sorted = false;
                swap( container + i, container + i + 1 );
            }
    } while( !sorted );

Da der Startwert von i = 1 ist, wird dann nicht container[0] übersprungen?

Swordfish

sorter3 schrieb:

Da der Startwert von i = 1 ist, [...]

wo?

for( i = 0; i < size - 1; ++i )

wird hier nicht zuerst i um 1 erhöht und dann erst der Rumpf ausgeführt?

SG1

Nein.

Swordfish schrieb:

Rastawasta schrieb:

Also entweder baust du hier wieder die Konstante SIZE ein, oder du prüfst die Länge per sizeof() Operator zur Laufzeit.
Letzteres ist wichtig, wenn das Array eine dynamische Größe haben soll, die sich zur Laufzeit ändern kann.

sizeof wird nicht zur runtime ausgewertet, sondern zur compiletime. Für irgendwas mit dynamischer Größe wirst mit sizeof nicht glücklich.

In C99 gibt es Fälle, in denen sizeof zur Runtime auswerten kann:
http://en.wikipedia.org/wiki/Sizeof#Using_sizeof_with_arrays

@SG1
Ok, ich dachte die Auswertungsreihenfolge gilt auch für die for-Schleife.
Das wärs dann an Fragen meinerseits. Danke für die Hilfe.

sorter3 schrieb:

@SG1
Ok, ich dachte die Auswertungsreihenfolge gilt auch für die for-Schleife.
Das wärs dann an Fragen meinerseits. Danke für die Hilfe.

Klar gilt die.
Aber der Inkrement beim for (der Teil nach dem 2. Semikolon) wird direkt nach dem Schleifenrumpf ausgeführt. Egal was da steht.

for(a;b;c) d;

ist wie

a;
while(b) {
  d;
  c;
}

Es gibt einen Unterschied, wenn a auch eine Definition enthält.
Bei for ist die Variable nur während der Schleife gültig. Bei while auch danach.

Da du dort aber beim ++i mit dem Ergebnis nichts machst, ist es da egal, ob du Post-oder Preinkrement schreibst.