Die Bestimmung der Länge einer String-Literal

Gegeben ein array von Zeigern auf string-Literale:

char *textMessages[] = {
    "Small text message",
    "Slightly larger text message",
    "A really large text message that "
    "is spread over multiple lines"
}

Wie wird man bestimmt die Länge eines bestimmten string-literal - sagen die Dritten? Ich habe versucht, mit dem sizeof-Befehl wie folgt:

int size = sizeof(textMessages[2]);

Aber das Ergebnis scheint zu sein, die Anzahl der Zeiger im array, sondern als die Länge der string-literal.

sizeof(textMessages[2]) wird der Ertrag der Größe der char* geben. Es ist rein zufällig, dass sizeof(char*) geschieht, werden 4 auf Ihrem system, und nichts zu tun mit der Anzahl der Elemente im array.
Sollten Sie mithilfe der definition static const char textMesssages[][4] für das array.
Es gibt nur drei Zeiger im array (Hinweis: die string-Verkettung).
Naja, meinen Punkt nicht wirklich liegen, in der Wahl der Anzahl, obwohl ich würde befürworten, dass eine sentinel-Wert.

InformationsquelleAutor Zack | 2012-09-22

  1. 18

    Wenn man die Zahl berechnet compile-Zeit (im Gegensatz zu den zur Laufzeit mit strlen), ist es vollkommen in Ordnung, einen Ausdruck verwenden, wie

    sizeof "A really large text message that "
       "is spread over multiple lines";

    Möchten Sie vielleicht ein makro verwenden, um zu vermeiden, Wiederholung der long-literal, aber:

    #define LONGLITERAL "A really large text message that " \
                    "is spread over multiple lines"

    Beachten Sie, dass der zurückgegebene Wert von sizeof umfasst der terminierenden NULL, so ist eine mehr als strlen.

    Ich wünschte, um zu bestimmen, die Länge der jede Zeichenfolge, so dass ich index der Längen und übergeben Sie an eine Funktion. Ist es möglich zu berechnen, wie ein array von Längen zur compile-Zeit?
    Mein Ansatz wäre, deklarieren und initialisieren Sie ein array von struct { char *ptr; size_t len; } x[]. Dann können Sie anrufen foo(x[i].ptr, x[i].len). Da C nicht halten die string-Längen herum, es gibt keine andere Möglichkeit, als zu verfolgen, string-Längen in Ihrem code.

    InformationsquelleAutor Jens

  2. 14

    Mein Vorschlag wäre die Verwendung von strlen und schalten Sie auf compiler-Optimierungen.

    Z.B. mit gcc 4.7 auf x86:

    #include <string.h>
static const char *textMessages[3] = {
    "Small text message",
    "Slightly larger text message",
    "A really large text message that "
    "is spread over multiple lines"
};

size_t longmessagelen(void)
{
  return strlen(textMessages[2]);
}

    Nach dem ausführen make CFLAGS="-ggdb -O3" example.o:

    $ gdb example.o
(gdb) disassemble longmessagelen
   0x00000000 <+0>: mov    $0x3e,%eax
   0x00000005 <+5>: ret

    I. e. der compiler ersetzt den Aufruf strlen mit den Konstanten Wert 0x3e = 62.

    Verschwenden Sie keine Zeit mit Optimierungen, die der compiler für Sie tun können!

    InformationsquelleAutor privatepolly

  3. 0

    strlen vielleicht?

    size_t size = strlen(textMessages[2]);
    Warum berechnen Sie diese Zahl zur Laufzeit, wenn festgestellt werden kann, zur compile-Zeit?
    Nicht, es sei denn, Sie kennen auch den string zur compile-Zeit.
    ja, Sie wissen, die Länge zur compile-Zeit (die Frage sagt "String-Literal")

    InformationsquelleAutor Tudor

  4. 0

    Sollten Sie die strlen() Bibliothek Methode, um die Länge einer Zeichenkette. sizeof geben Sie die Größe der textMessages[2], ein Zeiger, der würde in der Maschine abhängig (4 bytes oder 8 bytes).

    Nicht du meinst 4 oder 8 bytes? Es sei denn, Sie haben eine 16-bit-Maschine...
    gut, danke für die Korrektur 🙂

    InformationsquelleAutor Vikdor

  5. 0

    strlen Sie können die Länge der Zeichenfolge in der Erwägung, dass sizeof zurückkehren wird, die Größe der Daten Typ in Bytes, die Sie eingegeben haben, als parameter.

    strlen

    sizeof

    InformationsquelleAutor Abhineet

  6. 0

    Ich werde dir etwas sagen, nach meinem Wissen arrays ein Zeiger die gleiche Sache außer wenn Sie sizeof.

    Wenn Sie sizeof auf einen Zeiger wird es wieder immer 4 BYTE unabhängig von der Sache, die-Zeiger, aber wenn es von der verwendeten Arrays wird es wieder , Wie lange das array ist groß in bytes?.

    In Sie Beispiel hier *textMessage[] ist array von Zeiger so, wenn Sie sizeof(textMessage[2]) wird es wieder 4 BYTE weil textMessage[2] ist ein Zeiger.

    Ich hoffe, es wird nützlich sein für Sie.

    Ich Verstand nicht, was Sie wollen
    Meine Absicht war es zu sagen, Sie zu verbessern Sie Ihr wissen über die Unterschiede von arrays und Zeigern durch das Lesen von c-faq.com/aryptr/index.html Arrays sind keine Zeiger, und Sie sind oft 2 oder 8 statt 4 bytes, und Ihre Größe kann auch davon abhängen, welche Art Sie zeigen. Also, das meiste, was du geschrieben hast ist technisch falsch.
    Okay danke @jens
    Zeiger sind nicht immer 4 bytes.

    InformationsquelleAutor Mahmoud Emam

  7. 0

    Könnten Sie nutzen die Tatsache, dass die Werte in einem array hintereinander:

    const char *messages[] = {
    "footer",
    "barter",
    "banger"
};

size_t sizeOfMessage1 = (messages[1] - messages[0]) / sizeof(char); //7   (6 chars + '\0')

    Die Größe ist bestimmt durch die Grenzen der Elemente. Der Raum zwischen dem Anfang der ersten und Anfang des zweiten Elements die Größe des ersten.

    Dieser beinhaltet die Kündigung \0. Die Lösung, natürlich, funktioniert nur richtig mit Konstanten strings. Wenn die Saiten gewesen wäre Zeiger, die Sie erhalten würden, der die Größe eines Zeigers statt der Länge der Zeichenfolge.

    Das ist nicht garantiert, um zu arbeiten. Wenn die Felder ausgerichtet sind, kann dies yield falschen Größen und es können andere Einschränkungen eingeführt, durch den compiler, wie das Zusammenführen identische strings.
    Auch benötigen Sie mindestens zwei Elemente im array.

    Dieser ist nicht garantiert, um zu arbeiten. Während der Zeiger im array müssen aufeinander folgend sein, die string-Literale müssen nicht. Denke, der Ausrichtung und so. Oder mit den gleichen Zeiger für identische string-Literale.
    Du hast Recht, Ausrichtung brechen würde diese (aber kontrollierbar). Verschiedene Größen für char brechen würde. Ich werde mark meine Antwort als nicht zuverlässig.
    Die Zusammenführung identischer Zeichenfolgen, eine gemeinsame Optimierung, auch bricht es.

    InformationsquelleAutor nemo

Schreibe einen Kommentar