# Dreieckstausch mit Adressen



## xargon (20. April 2004)

Hiho!
Folgendes: Ich lerne gerade C++ und bin gerade bei dem Thema "Strukturen".
Hab da gerade ne Aufgabe aus dem Buch, dort soll man ein Struktur-Array sortieren (nach Werten aus der Struktur). Allerdings soll man nur die Adressen jeweils vertauschen und nicht den Inhalt der einzelnen Strukturelemente!
Das Problem ist nun: Ich habe den Dreieckstausch für die Adressen 1:1 aus dem Buch abgeschrieben, aber wenn ich das Programm dann ausführen will, stürzt es ab (progge mit Dev-Cpp).
Ich habe auch schon zig andere Sachen ausprobiert, aber nichts hat geklappt.
Hier mal der ganze Code (Struktur hier auf eine int Variable reduziert):

```
#include <iostream.h>
#include <stdio.h>
#include <conio.c>
#include <windows.h>

const int i=10;

struct kontos
{
int knr;
};

void sortiere(kontos *ptr)
{
kontos *hilfe;

    for(int x=0;x<i;x++)
    {
        for(int y=x+1;y<i;y++)
        {
                if((*(ptr+x)).knr>(*(ptr+y)).knr)
                {
                        //Hier der Dreieckstausch aus dem Buch:
                *hilfe=*(ptr+x);
                *(ptr+x)=*(ptr+y);
                *(ptr+y)=*hilfe;
                //_getch();
                }
        }
    }
}


main()
{
kontos konten[i];

    /* 
    srand(GetTickCount());
    for(int x=0;x<i;x++)
    {
    konten[x].knr=rand()%1000;
    }
    */
    
    int f=0;
    for(int g=9;g>=0;g--)
    {
    konten[f].knr=g;
    f++;
    }
    
    for(int x=0;x<i;x++)
    {
    cout<<konten[x].knr<<"\n";
    }
    
    _getch();
    sortiere(konten);
    
    for(int x=0;x<i;x++)
    {
    cout<<konten[x].knr<<"\n";
    }
    
_getch();
}
```


----------



## basd (20. April 2004)

Bitte das nächste mal Code Tags verwenden damit der Code besser aussieht !
[ CODE ] Dein Code  [/ CODE ]

Das Problem ist , du definierst ein Zeiger hilfe und schreibst auf den Inhalt auf den er zeigt (
	
	
	



```
*hilfe=*(ptr+x);
```
  ), da er nirgends ausgerichtet ist gibt es eine Accessviolation .
Definierst du hilfe als Struktur (zum Tauschen/ temporären festhalten) wird das Programm funktionieren.

```
kontos hilfe;
...
hilfe=*(ptr+x);
*(ptr+x)=*(ptr+y);
*(ptr+y)=hilfe;
```


----------



## xargon (20. April 2004)

hey!
danke dir!
ich glaube ich sollte mal den autoren des buches aufsuchen, das ist nämlich nicht der erste fehler im buch *g*

cya
xar


----------



## basd (20. April 2004)

Ich fürchte der liebe Autor wollte eigentlich was anderes mit dieser Übung durchführen. Ist die Struktur nämlich recht groß ist diese Methode natürlich nicht wirklich gut.

Mann könnte natürlich sich ein Array an Zeigern erstellen und diese sortieren, damit hätte man die Daten indirekt sortiert ohne den ganzen Speicher umkopiert zu haben.

Aber schreibe ihn mal an, er will sein Buch bestimmt auch verbessern.


----------



## xargon (21. April 2004)

hmm, der autor schreibt dass hier aber nur die adressen umgespeichert werden..()

noch was: funktioniert das obige programm mit objekten genauso?
also wenn ich jetzt die adressen von objekten umspeichern will.

gruß
xar


----------



## basd (21. April 2004)

Wie gesagt im obigen Beispiel wird die ganze Struktur kopiert und nicht ein Zeiger auf sie.
Du müsstest  dir erst ein Array mit den Zeigern anlegen und diese Sortieren (müsstest die Sortierfunktion natürlich anpassen).

Wenn man nämlich 
TypX  x[100]; schreibt werden im Speicher 100 Objekte vom TypX hintereinander erstellt.
Du bräuchtest noch ein Array der Art 
 TypX*  y[100];

dann in 
	
	
	



```
y[i] = (x +i)
```
  kopieren (x ist ein Zeiger !).
umkopieren würdest du dann mit

```
kontos* hilfe;
...
hilfe=*(ptr+x);
*(ptr+x)=*(ptr+y);
*(ptr+y)=hilfe;
```


----------



## xargon (22. April 2004)

irgendwie will das net.
ich habe die sortier funktion jetzt so umgebaut, dass ich als parameter einen  zeiger *ptr  und einen zeiger *strukt übergebe.
in *ptr steckt die anfangsadresse vom zeiger array das auf mein struktur array zeigt. und *strukt ist ein zeiger auf die anfangs adresse der struktur (nur um direkt zugreifen zu können, damit ich den vergleich beim sortieren anstellen kann.)
die ausgabe der struktur erfolgt über das zeiger array.


```
for(int x=0;x<i;x++)
    {
    cout<<zkonten[x]->knr<<"\n";
    }
```

hier erstmal der anfang des programms:


```
kontos konten[i];
kontos *zkonten[i],*x;
x=konten;

    for(int g=0;g<i;g++)
    {
    zkonten[g]=(x+g);
    }
```

so, das müsste ja eigentlich soweit richtig sein.
der funktionsaufruf sieht so aus: sortiere(zkonten,konten);
Die Funktion sieht nun so aus:


```
void sortiere(kontos *ptr,kontos *strukt)
{
kontos *hilfe;

    for(int x=0;x<i;x++)
    {
        for(int y=x+1;y<i;y++)
        {        
                if((*(strukt+x)).knr>(*(strukt+y)).knr)
                {
                hilfe=*(ptr+x);
                *(ptr+x)=*(ptr+y);
                *(ptr+y)=hilfe;
                }
        }
    }
}
```

da spuckt der mir folgende fehlermeldungen aus:

*cannot convert `kontos'*    für: _hilfe=*(ptr+x);_ 

*no match for `kontos& = *    für:  _*(ptr+y)=hilfe;_
*candidates are: kontos& * 

und beim Funktionsaufruf gibt es auch noch eine Fehlermeldung:
*cannot convert `* 


oh man, ich glaub ich bin einfach zu dämlich


----------



## basd (22. April 2004)

Du machst da was falsch ! Der Prototyp der sortier funktion muss wie folgt aussehen:
 sortiere(kontos ** zkonten ,kontos * konten, int Anzahl ); // zkonten ist Zeiger auf Zeiger

Wenn du die Anzahl übergibst ist es universeller einsetzbar ! (Wenn du bsihen überlegst kannst du rauskriegen wieso eigentlich kontos * konten  überflüssig ist).


----------



## xargon (25. April 2004)

so! nu geht's endlich!
hier der komplette code:


```
#include <iostream.h>
#include <stdio.h>
#include <conio.c>
#include <windows.h>

const int i=10000;

struct kontos
{
int knr;
};

void sortiere(kontos **ptr)
{
clrscr();
kontos *hilfe;

    for(int x=0;x<i;x++)
    {
        for(int y=x+1;y<i;y++)
        {                
                if((*(*(ptr+x))).knr>(*(*(ptr+y))).knr)
                {
                hilfe=*(ptr+x);
                *(ptr+x)=*(ptr+y);
                *(ptr+y)=hilfe;
                //_getch();
                }
        }
    }

}


main()
{
kontos konten[i];
kontos *zkonten[i],*x;
x=konten;

    for(int g=0;g<i;g++)
    {
    zkonten[g]=(x+g);
    }

    srand(GetTickCount());
    
    
    for(int x=0;x<i;x++)
    {
    konten[x].knr=rand()%1000;
    }
    
    
    /*
    int f=0;
    for(int g=9;g>=0;g--)
    {
    konten[f].knr=g;
    f++;
    }
    */
    /*
    for(int x=0;x<i;x++)
    {
    cout<<zkonten[x]->knr<<"\n";
    }
    */
    _getch();
    sortiere(zkonten);
    
    for(int x=0;x<i;x++)
    {
    cout<<zkonten[x]->knr<<"\n";
    }
    
_getch();
}
```


----------

