verketten const char * strings

Ich bin verwirrt über char * und const char *. In meinem Beispiel bin ich mir nicht sicher, wie Sie Sie zusammen. Ich habe mehrere const char * strings möchte ich zu verketten, um eine endgültige const char * string.

struct MyException : public std::exception
{
  const char *source;
  int number;
  const char *cause;

  MyException(const char *s, int n)
      : source(s), number(n) {}
  MyException(const char *s, const char *c)
      : source(s), number(0), cause(c) {}

  const char *what() const throw()
  {
    if (number != 0) {
      char buffer[1024];
      //why does this not work?
      cause = strerror_r(number, buffer, 1024);
    }

    //how to concatenate the strings?
    return source + ": " + cause;
  }
};

Warum die Arbeit mit cstrings? Sind Sie beschränkt, für Sie? Ich würde Ihnen empfehlen, std::string.
Ist das eine übung? Wenn nicht könnte man machen das Leben einfacher mit std::strings ??
Dito, dito. Benutzen Sie std::string. viel bessere Lösung für die meisten Probleme mit cstrings.
es soll nicht auf ... beim werfen, nicht diring Konstruktion. alle die <stdexcept> Klassen, abgeleitet von std::exception zu verwenden std::string!

InformationsquelleAutor multiholle | 2012-07-26

c++char concatenation const string

Können Sie speichern eine std::string und immer noch zurückgeben const char * von Ihr was Funktion.

struct MyException : public std::exception
{
private:
  std::string message;  

public:    
  MyException(const char *s, int n) {
    char buffer[1024];
    strerror_r(n, buffer, 1024);
    message.reserve(strlen(s) + 2 + strlen(buffer));
    message = s;
    message += ": ";
    message += buffer;
  }

  MyException(const char *s, const char *c) {
    message.reserve(strlen(s) + 2 + strlen(c));
    message = s;
    message += ": ";
    message += c;
  }

  const char *what() const throw()
  {
    return message.c_str();
  }
};

InformationsquelleAutor Benjamin Lindley

2

Verwenden Sie einfach strcat() und strcpy() Funktion von string.h.

http://www.cplusplus.com/reference/clibrary/cstring/strcat/
http://www.cplusplus.com/reference/clibrary/cstring/strcpy/

Auch, da Sie nicht haben, um änderung des ursprünglichen strings, der Unterschied zwischen const char* und char* egal.

Vergessen Sie auch nicht malloc() (reservieren Sie den Platz für) die erforderliche Größe der Ziel-string.
- +1 für die Annahme, strcat, statt std:string. Ich bin alte Schule.
- Lassen Sie zum Blickfang mit der Verantwortung für die Speicherfreigabe?
- Viele Male malloc steht unmittelbar bevor.
- Was, wenn Sie verlieren die ursprünglichen Zeichenfolgen bevor man what()? Oder kann es nur mit literalen und globalen Variablen? Dies schafft eine Schnittstelle, die ist einfach schrecklich. Mit einem std::string löst die meisten dieser.
- Wenn ich mich nicht Irre, der OP explizit aufgefordert, über die char* - strings.
- Er Tat. Aber ich denke, so lange der Eingang (die Argumente an den Konstruktor) ist die gleiche (zwei char* oder eine char* und ein int) und die Ausgabe (der Rückgabewert von dem, was()) ist ein const char* passt es sich den Anforderungen. Wenn ein std::string dient als Vermittler, das sollte in Ordnung sein, und bevorzugt, wenn er den code s Schnittstelle 14 mal besser.
- Sicher, das ist schnell wie die Hölle.
InformationsquelleAutor Rok Kralj
2

Dies ist, wie ich dies umsetzen:
```
struct MyException : public std::exception
{
public:
  const char *source;
  int number;
  const char *cause;
private:
  char buffer[1024]; //#1
  std::string message; //#2

  std::string build_message() {
    if (number != 0) {
      cause = strerror_r(number, buffer, 1024); //use the member buffer
    }
    std::string s; //#3
    s.reserve(strlen(source) + 2 + strlen(cause));
    return s + source + ": " + cause;
  }

public:
  MyException(const char *s, int n)
      : source(s), number(n), cause(), message(build_message()) {}
  MyException(const char *s, const char *c)
      : source(s), number(0), cause(c), message(build_message()) {}

  const char *what() const throw()
  {
    return message.c_str(); //#4
  }
};
```
Dinge zu beachten:
1. Den original-code wurde mit einem lokale variable für einen Puffer. Das ist eine schlechte Idee, da der Zeiger gespeichert, in cause wäre ungültig ist der moment, der Geltungsbereich endet.
2. Für die verkettete Nachricht, die dynamische Zuordnung erforderlich wäre. Und das bedeutet auch, dass die Bereinigung der Lagerung erforderlich wäre. Ich schnappte mir ein vorhandenes Werkzeug, das funktioniert und liefert string-ähnliche Operationen: std::string.
3. Mit std::string Verkettung kann getan werden, mit der + Betreiber. Beachten Sie, wie ich es gefragt reservieren Speicher für die Größe erwartet. Dies ist Speicher, der eine Optimierung und ist nicht erforderlich: der string würde genügend Speicher oder so.
4. what nicht werfen eine Ausnahme, ansonsten wird ein Anruf std::unexpected entstehen würden. Also der string nicht zugeordnet werden kann, hier.
InformationsquelleAutor R. Martinho Fernandes
1

Wenn Sie arbeiten müssen, mit char* Zeiger, die Sie verwenden möchten strcat. strcat nimmt zwei Argumente, die char* und ein const char* ab und fügt die Zeichenfolge gezeigt, durch den const char* auf die char*. Dies bedeutet, dass müssen Sie zuerst kopieren Sie Ihre ersten string über.

Werden Sie wollen, um etwas wie das hier tun:
```
char* Concatenate(const char* first, const char* second)
{
  char* mixed = new char[strlen(first) + strlen(second) + 2 /* for the ': ' */ + 1 /* for the NULL */];
  strcpy(mixed, first);
  strcat(mixed, ": ");
  strcat(mixed, second);

  return mixed;
}
```
Ist das nicht nur hässlich? Und denken Sie daran,, weil Sie haben dynamisch zugeteilt char* zurückgegeben, die Funktion der Aufrufer muss sich daran erinnern delete[] es. Diese Hässlichkeit und der Notwendigkeit der Sicherstellung der Aufrufer bereinigt, die in der richtigen Weise ist, warum Sie sind besser mit einem string-Implementierung wie std::string.
- Und diese kann nicht aufgerufen werden, in what weil new werfen kann.
InformationsquelleAutor Jack Aidley
0

Reservieren eines Puffers der Größe strlen(source) + strlen(cause) + 3 und verwenden sprintf zu erstellen Sie Ihre Nachricht. Eigentlich kann man sich bewegen, diesen code an den Konstruktor so, dass what wird einfach getter.

InformationsquelleAutor tumdum
0

Wenn Sie wirklich müssen, verwenden Sie c-strings haben, sollten Sie sich strcat() verketten Sie zusammen. Aber, da Sie erstellen eine benutzerdefinierte Ausnahme, es wäre sinnvoll, zu prüfen, mit std::string statt, denn es ist mehr freundlich zu verwenden in C++.

InformationsquelleAutor Code-Apprentice

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.