Vertauschen Sie zwei Variablen mit Zeigern

Bin ich zu schreiben versucht, eine swap-Funktion mit Zeiger(speziell ein void-Zeiger)-Referenz, aber mein code nicht funktioniert. Hier ist mein code:

void swap(void *p1,void *p2) 
{
    int temp;   
    temp=*((int*)p2);
    p2=p1; 
    p1=&temp;
}

int main() 
{
    int i=4;
    int j=5; 
    cout<<i<<j<<endl;
    swap(&i,&j); 
    cout<<i<<j<<endl;
    return 0;
}

Wohin gehe ich falsch?

Dieser defekt ist in einer Menge weisen, aber das wichtigste Problem (IMO) ist die Zuordnung p1,p2 mit Werten, während Sie tatsächlich benötigen, weisen Sie der Adresse, die Sie ansprechen. Dies ist nicht das einzige Problem, nur das wichtigste IMO.
Sie müssen übergeben Sie den Zeiger per Referenz ?
Da Sie austauschen ints, brauchen Sie nicht zu pass-Parameter für die Funktion als Hohlräume.

InformationsquelleAutor dead programmer | 2012-12-20

c++void-pointers

6

Der code funktioniert nicht, weil Sie nicht dereferenzieren von Zeigern auf Zuweisungen. Es sollte
```
*((int*)p2)=*((int*)p1);
*((int*)p1)=temp;
```
Beachten Sie, dass Sie machen eine Annahme, dass void* Punkte zu einem int werden, was offensichtlich nicht immer der Fall. Im wesentlichen, könnte man genauso gut ersetzen void* mit int*, und loszuwerden des casts.

Einer allgemeineren Fall der API sollte wie folgt Aussehen:
```
void swap(void *p1,void *p2, size_t sz)
```
Intern die API sollte reservieren eines Puffers der Größe sz, eine memcpy hinein, und dann ein swap, wieder mit memcpy.

Dies wird vorausgesetzt, die Typen sind trivial kopierbar-.
Recht-im wesentlichen ergibt dies einen trivial-swap-Speicher-Inhalt in nicht-überlappende Regionen.

InformationsquelleAutor dasblinkenlight
2

Im Körper der Funktion, Sie sind durch das vertauschen der Werte von p1 und p2; Sie wollen nicht, das zu tun. Sie möchten, vertauschen Sie die Werte von dem, was p1 und p2 Punkt zu:
```
void swap(int *p1, int *p2)
{
  int tmp = *p1;
  *p1 = *p2;
  *p2 = tmp;
}
```
Ich weiß, Sie wollte void * für Ihre Argumente. Nicht. Würden Sie haben, um Sie zu werfen, um den entsprechenden Ziel-Typ zur Durchführung der Aufgaben sowieso:
```
int tmp = *(int *) p1;
*(int *) p1 = *(int *) p2;
*(int *) p2 = tmp;
```
Igitt. Sie sind sich nicht speichern selbst etwas, indem Sie die Argumente void *.

Da bist du offensichtlich schreiben von C++ ist, kannst du die generische Funktion, die eine Vorlage verwenden:
```
template<typename T>
void swap(T *p1, T *p2)
{
  T tmp = *p1;
  *p1 = *p2;
  *p2 = tmp;
}
```
Sogar noch besser, verwenden Sie eine Vorlage und Referenzen, du bist also nicht der Umgang mit Zeigern an alle:
```
template<typename T>
void swap(T &p1, T &p2)
{
  T tmp = p1;
  p1 = p2;
  p2 = tmp;
}
```
Warten Sie eine minute - habe ich nicht gesehen, dass die Letzte Funktion irgendwo?

InformationsquelleAutor John Bode

mit memory-Funktionen

void swap (void *vp1, void *vp2, const int size) {
char *buffer = (char *)malloc(sizeof(char)*size);
memcpy(buffer, vp1, size);
memcpy(vp1, vp2, size);
memcpy(vp2, buffer, size);
free(buffer);
}

int main()
{
int a = 10, b = 20;
printf("%d %d"a,b);
swap(&a, &b, sizeof(int));
printf("%d %d"a,b);

}

Output is:

10 , 20
20 , 10

wenn wir noch nicht wissen-Daten geben, dann nutzen wir void.

Tatsächlich, in C++ verwenden wir template <typename T> wenn wir nicht wissen, die Art noch nicht. Der compiler wissen, verwenden Sie den Typ real T und dann auf Fehler prüfen. Das ist, warum wir haben template <typename T> std::swap(T&, T&)

InformationsquelleAutor ɹɐqʞɐ zoɹǝɟ

0

Den Sie Bearbeiten, Kopien der Zeiger, nicht den Inhalt.
Sollten Sie so etwas tun (zeigen Sie auf die Idee, dies würde nicht funktionieren ohne wirft und es wäre immer noch nicht eine gute Idee, mit):
```
temp = *p2
*p2 = *p1;
*p1 = temp;
```
Sind Sie gehen zu müssen, Zeiger auf Zeiger, wenn Sie wollen, tauschen Sie Ihre Hinweise geben:
```
void swap(void** ptr1, void** ptr2);
```
oder Referenzen auf Zeiger:
```
void swap(void*& ptr1, void*& ptr2);
```
Oder, da du dich offensichtlich mit C++, könnten Sie Referenzen und Vorlagen zu tauschen, jede Art von Daten. Aber sind Sie sicher, dass Sie alles verstanden, die Grundlagen der Sprache?

Glück

InformationsquelleAutor cmc
0

Versuchen Sie dies:
```
#include <iostream>
using namespace std;

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

int main() {
  int a, b;
  cin >> a >> b;
  swap( &a, &b );
  cout << a << " " << b;
  return 0;
}
```
Bevor Sie dereferenzieren Sie die Zeiger a und b, müssen Sie zuerst konvertieren Sie Sie in int*. Nach, dass Sie nur ausführen tauschen.

Hinweis: Sie nicht brauchen, pass void* als parameter. Wenn Sie pass int*s, es wird auch richtig (und besser lesbar).

Hinweis[2]: Da Sie Programmieren in C++ könnte man anstelle von Zeigern verweist.

InformationsquelleAutor Rontogiannis Aristofanis

versuchen folgenden code:

#include <iostream>
using namespace std;

void Swap(int **ptr1, int **ptr2){
    //Swapping the contents of p1 and p2 in the driver function
    int *temp;
    temp = *ptr1;                   
    *ptr1 = *ptr2;
    *ptr2 = temp;
    //Swapping the contents of x and y in the driver function
    int temp;
    temp = **ptr1;                  
    **ptr1 = **ptr2;
    **ptr2 = temp;
}

int main(){
    int x = 10, y = 15;
    int *p1 = nullptr;
    p1 = &x;
    int *p2 = nullptr;
    p2 = &y;
    cout << x << ' ' << y << endl;
    cout << *p1 << ' ' << *p2 << endl;
    Swap(&p1,&p2);
    cout << x << ' ' << y << endl;
    cout << *p1 << ' ' << *p2 << endl;
}

InformationsquelleAutor Hamza

0

Tauschen Sie den Inhalt von p1 und p2 in der Fahrer-Funktion
code funktioniert nicht. Dies ist wahrscheinlich, weil Sie versuchen, die swap-Speicher-Adresse Start und os beschränkt. ??
Die Speicher-Funktionen aber macht die Arbeit.

Diese kaum helfen, OP. Können Sie ein Beispiel geben, wie der "memory-Funktionen" arbeiten?

InformationsquelleAutor John

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.