Konvertieren von Zeichenfolgen an den Pointer

Ich versuche zu konvertieren, die einen Zeiger auf string, und der string zurück, um den Zeiger (lexikalische Gießen) mit dem folgenden code. Die Umwandlung von Zeiger auf string funktioniert, aber nicht Umgekehrt.

Warum geschieht dies?
Gibt es eine andere Möglichkeit kann ich umwandeln eines string zu einem Zeiger?

Ich bin nicht besorgt über die Fehler, die durch falsche format der Zeichenfolge. Die Zeichenfolge, die ich versuche zu konvertieren, ein Zeiger wird immer erzeugt werden durch die Umwandlung einen Zeiger auf string.

Hier der code:

//TB_ConvertToString.cpp

#include<iostream>
#include<cstdio>
#include<sstream>
#include<string>

//Functions to convert data types to and from strings   
template <typename T> std::string ToString ( T Number )
{
    std::stringstream ss;
    ss << Number;
    return ss.str();
};

template <typename T> 
T FromString ( const std::string &Text )
{
    std::stringstream ss(Text);
    T result;
    ss >> result;
    return result;
}
//-------------------------------------------------


using namespace std;

int main()
{
    int a =10;  
    int* p1 = &a;
    //this works------------
    string s1 = ToString<int *>(p1);
    printf("\n ptr: %s",s1.c_str());
    //----------------------

    //this gives compilation errors -----
    //int * p2 = FromString<int *>(s1);
    //printf("\n ptr: %p",p2);
    //----------------------


    cout<<"\n\n";
    return 0;
};

Un-kommentieren das problem Abschnitt gibt der folgende Kompilierungsfehler:

nehak@Marvin:~/Desktop$ g++ TB_ConvertToString.cpp 
TB_ConvertToString.cpp: In function ‘T FromString(const string&) [with T = int*, std::string = std::basic_string<char>]’:
TB_ConvertToString.cpp:39:33:   instantiated from here
TB_ConvertToString.cpp:21:2: error: no match for ‘operator>>’ in ‘ss >> result’
TB_ConvertToString.cpp:21:2: note: candidates are:
/usr/include/c++/4.6/istream:122:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_istream<_CharT, _Traits>::__istream_type& (*)(std::basic_istream<_CharT, _Traits>::__istream_type&)) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:122:7: note:   no known conversion for argument 1 from ‘int*’ to ‘std::basic_istream<char>::__istream_type& (*)(std::basic_istream<char>::__istream_type&) {aka std::basic_istream<char>& (*)(std::basic_istream<char>&)}’
/usr/include/c++/4.6/istream:126:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_istream<_CharT, _Traits>::__ios_type& (*)(std::basic_istream<_CharT, _Traits>::__ios_type&)) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>, std::basic_istream<_CharT, _Traits>::__ios_type = std::basic_ios<char>]
/usr/include/c++/4.6/istream:126:7: note:   no known conversion for argument 1 from ‘int*’ to ‘std::basic_istream<char>::__ios_type& (*)(std::basic_istream<char>::__ios_type&) {aka std::basic_ios<char>& (*)(std::basic_ios<char>&)}’
/usr/include/c++/4.6/istream:133:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(std::ios_base& (*)(std::ios_base&)) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:133:7: note:   no known conversion for argument 1 from ‘int*’ to ‘std::ios_base& (*)(std::ios_base&)’
/usr/include/c++/4.6/istream:169:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(bool&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:169:7: note:   no known conversion for argument 1 from ‘int*’ to ‘bool&’
/usr/include/c++/4.6/istream:173:7: note: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(short int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.6/istream:173:7: note:   no known conversion for argument 1 from ‘int*’ to ‘short int&’
/usr/include/c++/4.6/istream:176:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(short unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:176:7: note:   no known conversion for argument 1 from ‘int*’ to ‘short unsigned int&’
/usr/include/c++/4.6/istream:180:7: note: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(int&) [with _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.6/istream:180:7: note:   no known conversion for argument 1 from ‘int*’ to ‘int&’
/usr/include/c++/4.6/istream:183:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:183:7: note:   no known conversion for argument 1 from ‘int*’ to ‘unsigned int&’
/usr/include/c++/4.6/istream:187:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long int&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:187:7: note:   no known conversion for argument 1 from ‘int*’ to ‘long int&’
/usr/include/c++/4.6/istream:191:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:191:7: note:   no known conversion for argument 1 from ‘int*’ to ‘long unsigned int&’
/usr/include/c++/4.6/istream:196:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long long int&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:196:7: note:   no known conversion for argument 1 from ‘int*’ to ‘long long int&’
/usr/include/c++/4.6/istream:200:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long long unsigned int&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:200:7: note:   no known conversion for argument 1 from ‘int*’ to ‘long long unsigned int&’
/usr/include/c++/4.6/istream:205:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(float&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:205:7: note:   no known conversion for argument 1 from ‘int*’ to ‘float&’
/usr/include/c++/4.6/istream:209:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(double&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:209:7: note:   no known conversion for argument 1 from ‘int*’ to ‘double&’
/usr/include/c++/4.6/istream:213:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(long double&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:213:7: note:   no known conversion for argument 1 from ‘int*’ to ‘long double&’
/usr/include/c++/4.6/istream:217:7: note: std::basic_istream<_CharT, _Traits>::__istream_type& std::basic_istream<_CharT, _Traits>::operator>>(void*&) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__istream_type = std::basic_istream<char>]
/usr/include/c++/4.6/istream:217:7: note:   no known conversion for argument 1 from ‘int*’ to ‘void*&’
/usr/include/c++/4.6/istream:241:7: note: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::operator>>(std::basic_istream<_CharT, _Traits>::__streambuf_type*) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::__streambuf_type = std::basic_streambuf<char>]
/usr/include/c++/4.6/istream:241:7: note:   no known conversion for argument 1 from ‘int*’ to ‘std::basic_istream<char>::__streambuf_type* {aka std::basic_streambuf<char>*}’
/usr/include/c++/4.6/bits/basic_string.tcc:998:5: note: template<class _CharT, class _Traits, class _Alloc> std::basic_istream<_CharT, _Traits>& std::operator>>(std::basic_istream<_CharT, _Traits>&, std::basic_string<_CharT, _Traits, _Alloc>&)
/usr/include/c++/4.6/bits/istream.tcc:957:5: note: template<class _CharT2, class _Traits2> std::basic_istream<_CharT, _Traits>& std::operator>>(std::basic_istream<_CharT, _Traits>&, _CharT2*)
/usr/include/c++/4.6/bits/istream.tcc:925:5: note: template<class _CharT, class _Traits> std::basic_istream<_CharT, _Traits>& std::operator>>(std::basic_istream<_CharT, _Traits>&, _CharT&)
/usr/include/c++/4.6/istream:709:5: note: template<class _Traits> std::basic_istream<char, _Traits>& std::operator>>(std::basic_istream<char, _Traits>&, unsigned char&)
/usr/include/c++/4.6/istream:714:5: note: template<class _Traits> std::basic_istream<char, _Traits>& std::operator>>(std::basic_istream<char, _Traits>&, signed char&)
/usr/include/c++/4.6/istream:756:5: note: template<class _Traits> std::basic_istream<char, _Traits>& std::operator>>(std::basic_istream<char, _Traits>&, unsigned char*)
/usr/include/c++/4.6/istream:761:5: note: template<class _Traits> std::basic_istream<char, _Traits>& std::operator>>(std::basic_istream<char, _Traits>&, signed char*)
nehak@Marvin:~/Desktop$

Definieren "doesn't work"
Dies tut compiler Fehler Hilfe an alle: "Ungültige Operanden für binäres expression ('std::stringstream' (aka 'basic_stringstream<char>') und 'int *')", In anderen Worten, es gibt keine überladene Extraktion Betreiber, die einen LS-istream und einen rhs-intptr. Seien Sie einfach froh, dass Sie nicht bestanden hat, ein char* oder würden Sie kämpfen mit segfaults eher als compiler-Fehler.
Warum tun Sie erwarten, dass es funktioniert? Sie versuchen zu streamen, die Inhalte einer std::stringstream in einen Zeiger.
Es ist ein << operator zum einfügen von Zeigern zu den streams, aber keine >> Betreiber für das extrahieren von Ihnen zurück.
Ihren Kommentar nicht erklären, warum es nicht funktionieren sollte. Es funktioniert für alle anderen integrierten Typen wie int, float etc - nur keine Zeiger. Die Fragen, die gefragt werden, wenn es keine andere Möglichkeit, um die Konvertierung zu tun, wenn der aktuelle nicht funktioniert.
Peter Holz : danke! bearbeitet die Frage.
Warum brauchen Sie, um dies zu tun? Für den Zeiger an Sinn zu machen, Sie müssen sich noch in den gleichen Prozess auf der gleichen physikalischen Maschine (es sei denn, Sie haben eine Art der festen Verbindung/Adressierung geht), und wenn das der Fall ist dann warum benötigen Sie zum speichern der Zeiger in eine intermediate Schnur? Ich kann sehen, warum Sie möglicherweise möchten, zu konvertieren von Zeiger auf Zeichenkette (für einen Menschen zu Lesen), aber kann nicht denken, warum würden Sie JEMALS gehen Sie zurück in die andere Richtung.

InformationsquelleAutor Neha Karanjkar | 2013-03-18

c++hex memory-address pointers string

Das problem ist, dass jeder Zeiger kann implizit sein cast zu void*, aber void* können nicht gegossen werden, um jede Art von Zeiger. In Ihrem Fall sollten Sie sich spezialisieren FromString - Funktion für alle Zeiger. Wie diese

template <typename T> 
T FromString ( const std::string &Text,
    std::enable_if< ! std::is_pointer< T >::value >::type * = nullptr )
{
    std::stringstream ss(Text);
    T result;
    ss >> result;
    return result;
}

template <typename T> 
T FromString ( const std::string &Text,
    std::enable_if< std::is_pointer< T >::value >::type * = nullptr )
{
    std::stringstream ss(Text);
    void * result;
    ss >> result;
    return (T)result;
}

Ich wusste nicht, stringstream>>void* durfte. Danke.

InformationsquelleAutor borisbn

4

Dein problem könnte tatsächlich eingeengt zu diesem einfachen Testfall:
```
std::stringstream ss("0xbf845748");
int* p2;
ss >> p2;
```
was nicht funktioniert, weil es keine solche überladung von >> operator, würde initialisiert den Zeiger. Um diese Extraktion der Zeiger arbeiten, könnten Sie void* oder Sie können sogar extrahieren Sie die integral-Nummer, dass ist groß genug, um diese Adresse zu verwenden und dann reinterpret_cast<T> um Ihren Zeiger auf diese Adresse verweisen, nur wirklich vorsichtig sein, nicht, um am Ende mit char* überlasten, denn das könnte dazu führen, Sie noch viel schlimmer Probleme, Sie sind den Umgang mit jetzt.

Nur beachten, dass der Versuch, initialisieren Sie einen Zeiger mit der Adresse gespeichert std::string ist wirklich eine schlechte Idee. Bevor Sie sich entscheiden, es zu machen, arbeiten, stellen Sie sicher, es ist wirklich das, was Sie hier wollen. Es sind wahrscheinlich viel vernünftiger Art und Weise, wie dies zu vermeiden.
- Selbst wenn dies geschehen ist, die OP ist immer noch verpflichtet, die write-format mit einem Zeiger auf den output-stream. Es gibt keine Garantie, dass write-format passen auf eine konsistente lese-format in so etwas wie einen uintptr_t auch mit hex eingeschaltet. Außerdem, das ganze Ding fällt auseinander, ohne eine void*-cast auf die original-Zeiger-schreiben, da es wird ein definierter Schriftsteller für char*. I. e. wenn char* ist immer die Vorlage der OP hat eine ganze Reihe neuer Probleme zu befürchten.
- In der Tat. Initialisieren Sie einen Zeiger mit der Adresse gespeichert std::string scheint keine richtige zu tun.
- ja, es ist eine schreckliche Idee. wenn er wirklich wollte, es zu Arbeit (das ist eine Reale Strecke) konnte er gewirkt (uintptr_t), dann schreiben, und das Gegenteil auf das Lesen. Aber dann ein SFINAE Problem auftaucht und eine spezielle version für std::is_pointer<T> würde wahrscheinlich erforderlich sein. Alles in allem eine rundum schlechte Idee, Stimme ich zu.
InformationsquelleAutor LihO

@LihO, danke! Das funktioniert. Ich musste std::hex beim extrahieren der Zeiger aber.

    string s1 = "0x7fff3e8aee1c";
    stringstream ss;
    ss<<s1;
    long long unsigned int i;
    ss>>std::hex>>i;
    int * i_ptr=reinterpret_cast<int *>(i);

Sie sollten uintptr_t.

InformationsquelleAutor Neha Karanjkar

0

Landete ich mit std::stoul.
```
void *p = std::stoul(str.c_str(), 0, 16);
```
Schauen Sie es hier https://beginningprogrammer.com/programming/convert-a-hex-address-in-a-string-to-a-pointer/

InformationsquelleAutor FernandoZ

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.