c ++ - Zuweisen einer Zeichenfolge zu null

Lerne ich C++ auf meinem eigenen. Ich habe folgenden code, aber es gibt Fehler.

#include <iostream>
#include <string>
using namespace std;


int setvalue(const char * value)
{
    string mValue;
    if(value!=0)
    {
       mValue=value;
    }
    else
    {
       mValue=0;
    }
}

int main ()
{
 const char* value = 0;
 setvalue(value);

 cin.get();
 return 0;
}

So wollen, um eine Funktion zu erstellen, welche akzeptiert char-Zeiger und ich möchte einen Zeiger übergeben. Die Funktion weist der Zeiger auf den member-Variablen. Ich bin vorbei ein null-Zeiger absichtlich. Folgendes ist der Fehler, die ich immer bin:

 D:\CPP\TestCP.cpp In function `int setvalue(const char*)': 

 note C:\Dev-Cpp\include\c++\3.4.2\bits\basic_string.h:422 candidates are: std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 

 note C:\Dev-Cpp\include\c++\3.4.2\bits\basic_string.h:422                 std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(const _CharT*) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 

 note C:\Dev-Cpp\include\c++\3.4.2\bits\basic_string.h:422                 std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(_CharT) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>]

es ist im Grunde beschweren sich über Zeile: mValue=0;

Warum gibt es Klagen über diese Linie? Ich kann nicht eine null zuweisen einer Zeichenfolge?

Kommentar zu dem Problem

Was sind Sie versuchen zu erreichen, indem Sie es auf 0? Kommentarautor: James McLaughlin

Der Zweck der Funktion ist es, den char* an die Funktion übergeben, und weisen Sie Sie, um es ein Mitglied string-variable. Also ich überprüfe zuerst, ob es null ist, wenn es null ist, dann statt der Dereferenzierung eines null-Zeiger ist, ich bin durch das zuweisen von null zu Zeichenkette. Also der Zweck ist, zu haben mValue und Wert zu enthalten ähnliche Werte. Danke. Kommentarautor: Maria

Aber mValue = Wert; würde nur tun, mValue = 0; wenn value ist ein null-Zeiger, wenn mValue = 0; gültig waren, so dass die zusätzliche Kontrolle ist nicht wirklich etwas tun. Es wäre genauso hinfällig. Kommentarautor: hvd

Vielleicht möchten Sie sich in boost::optional, wenn Sie sind auf der Unterscheidung zwischen einem leeren string und kein string. Kommentarautor: chris

@Maria - Sie können nicht lernen, C++, indem Sie versuchen es selbst, Sie müssen ein gutes Buch. Auch gcc 3.4.2 ist nicht ein guter compiler nicht mehr, es ist sehr alt. Kommentarautor: Bo Persson

InformationsquelleAutor der Frage Maria | 2012-07-23

c++

50

Kann ich nicht zuweisen einen null-Wert an einen String?

Nicht. std::string ist nicht ein Zeiger-Typ; es kann nicht gemacht werden, "null." Es können für die Abwesenheit eines Wertes, das ist, was ein null-Zeiger verwendet wird, zu stellen.

Kann es gemacht werden leer, durch die Zuweisung einer leeren Zeichenkette (s = "" oder s = std::string()) oder durch Beseitigung (s.clear()).

InformationsquelleAutor der Antwort James McNellis
12

Nicht zuordnen können NULL oder 0 einer C++ - std::string Objekt, weil das Objekt nicht ein Zeiger. Dies ist ein wesentlicher Unterschied zu C-style-strings; ein C-Stil-string kann entweder NULL oder eine gültige Zeichenfolge, in der Erwägung, dass C++ std::strings immer speichern Wert.

Gibt es keine einfache Lösung. Wenn Sie möchten, reservieren Sie einen sentinel-Wert (also die leere Zeichenfolge) ist, dann könnte man etwas tun, wie
```
const std::string NOT_A_STRING = "";

mValue = NOT_A_STRING;
```
Alternativ können Sie speichern einen Zeiger auf einen string, so dass Sie können setzen Sie ihn auf null:
```
std::string* mValue = NULL;

if (value) {
    mValue = new std::string(value);
}
```
Hoffe, das hilft!

InformationsquelleAutor der Antwort templatetypedef
4

Wörtliche 0 ist der Typ int und können Sie nicht zuordnen int zu std::string. Verwenden mValue.clear() oder weisen eine leere Zeichenfolge mValue="".

InformationsquelleAutor der Antwort Juraj Blaho
4

Gibt es zwei Methoden, um zu prüfen, welche den gleichen Effekt erzielen, für die Handhabung von null-Zeigern auf C-style strings.

Ternären operator
```
void setvalue(const char *value)
{
    std::string mValue = value ? value : "";

}
```
oder die bescheidenen if-Anweisung
```
void setvalue(const char *value)
{
    std::string mValue;
    if(value) mValue = value;

}
```
In beiden Fällen value ist nur zugeordnet mValue wenn value ist nicht ein null-Zeiger. In allen anderen Fällen (d.h. wenn value ist null) mValue enthält eine leere Zeichenfolge.

Ternären operator-Methode kann nützlich sein, für eine alternative Standard-string-literal in der Abwesenheit von einem Wert von value:
```
std::string mValue = value ? value : "(NULL)";
```
InformationsquelleAutor der Antwort David Cormack
1

Ich will nicht behaupten, dass es ein gute Idee (oder die Semantik der Verwendung von nullptr mit Dingen, die nicht Zeiger), aber es ist relativ einfach, eine Klasse zu erstellen die " null-Werte zulässt " - Semantik (siehe nullable_string).

Jedoch, dies ist eine viel bessere Passform für C++17 std::optional:
```
#include <string>
#include <iostream>
#include <optional>

//optional can be used as the return type of a factory that may fail
std::optional<std::string> create(bool b)
{
    if (b)
        return "Godzilla";
    else
        return {};
}

int main()
{
    std::cout << "create(false) returned "
              << create(false).value_or("empty") << std::endl;

    //optional-returning factory functions are usable as conditions of while and if
    if (auto str = create(true))
    {
        std::cout << "create(true) returned " << *str << std::endl;
    }
}
```
std::optional, wie im Beispiel gezeigt, wird die Wandelanleihe zu bool oder Sie können verwenden die has_value() Methode, mit Ausnahmen für schlechte Zugang, etc. Dies bietet Ihnen mit nullable-Semantik, die das zu sein scheint was Maria wurde zu erreichen versucht.

, Und wenn Sie nicht warten wollen, um für C++17-Kompatibilität, finden Sie diese Antwort zu Steigern.Optional.

InformationsquelleAutor der Antwort monkey0506
0

Den else Fall ist unncecessary, wenn Sie erstellen eine string Objekt, es ist standardmäßig leer.

InformationsquelleAutor der Antwort Naveen

Viele C-APIs verwenden, einen null-Zeiger, um anzuzeigen, "verwenden der Standard", z.B. mosquittopp. Hier ist das Muster, das ich verwende, basiert auf David Cormack's Antwort:

    mosqpp::tls_set(
        MqttOptions->CAFile.length() > 0 ? MqttOptions->CAFile.c_str() : NULL,
        MqttOptions->CAPath.length() > 0 ? MqttOptions->CAPath.c_str() : NULL,
        MqttOptions->CertFile.length() > 0 ? MqttOptions->CertFile.c_str() : NULL,
        MqttOptions->KeyFile.length() > 0 ? MqttOptions->KeyFile.c_str() : NULL
    );

Es ist ein wenig umständlich, aber können einem damit alles als std::string bis der API-Aufruf selbst.

InformationsquelleAutor der Antwort Robert Calhoun

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.