Kombiniere Char, um Char *

Question

Wirklich dumm C++ Frage, aber ich sehe es nicht in der Art und Weise abgedeckt, wie ich es brauche. Ich habe einen const Char *, den ich verschiedene Werte aus und in ihre eigenen Char * ziehen möchte. Zum Beispiel

const char* atr; 
// 
//Data is placed in atr 
// 

//Here's what I want to do, but obviously this doesn't compile 
char* _ts = atr[0] + atr[1]; 
char* _t0 = atr[2] + atr[3]; 

Vielen Dank im Voraus. Ich bin ein C++ Entwickler von Tag zu Tag, der im Grunde auf C++ 11 und darüber hinaus angesprochen wurde, also ist es etwas komisch, sich mit Zeichenzeigern zu befassen.

Answer 1

Wenn Sie wirklich Zeichen anstelle von Zeichenfolge verwenden möchten, hier ist Ihr Problem: Sie haben Ihre Zeiger nicht initialisiert. Versuchen Sie mit char* my_ptr = new char(atr[0]);

Answer 2

Diese Funktion wird eine Zeichenfolge bestehend aus den angegebenen zwei Zeichen. Vergessen Sie nicht, free es, wenn Sie damit fertig sind.

char* makeString (char c1, char c2) 
{ 
    char* buf = malloc(3); 
    buf[0] = c1; 
    buf[1] = c2; 
    buf[2] = 0; 
    return buf; 
} 

So, jetzt können Sie dies tun:

char* _ts = makeString (atr[0], atr[1]); 

Answer 3

Im Gegensatz zu C++, C nicht lassen Sie Betreiber überlasten, die die Funktion verantwortlich für std::string Verkettung Operator +. Daher erhalten Sie in C die Summe von zwei Zeichencodes, und Sie schreiben sie in einen Zeichenzeiger. Das ist nicht was Sie wollen.

Wenn die Anzahl der Orte, von denen Sie Zeichen Kommissionierung festgelegt ist, können Sie C-Strings mit der Initialisierung konstruieren:

char _ts[] = { atr[0], atr[1], 0 }; 
char _t0[] = { atr[2], atr[3], 0 }; 

Hinweis Nullabschluss am Ende dieses ist erforderlich, wenn Sie _ts verwenden möchten und _t0 als C-Saiten.

Demo.

Answer 4

_ts und _t0 sind Zeiger auf Speicherplätze vom Typ char. auf der rechten Seite des Gleichheitszeichens, wo Sie atr[0] + atr[1] tun, was dort passiert ist, sind Sie zuerst de-referenzieren die Speicherplätze von atr und (atr + 1) und erhalten die Werte dort. Hinweis: atr + 1 ist 1 Byte von atr entfernt, da atr vom Typ char ist und die Größe von (char) 1 Byte ist. so haben Sie jetzt zwei Zeichen Werte von atr [0] und atr [1] und obwohl sie vom Typ char sind, können diese Werte hinzugefügt werden, da in der C-Sprache der Zeichentyp wirklich eine 1 Byte ganze Zahl zwischen 0 und ist 255 basierend auf der ASCII-Tabelle. zum Beispiel ist der Wert von ‚A‘ dezimal 65. Der Wert von ‚a‘ ist dezimal 97. Weswegen so etwas wie dies funktioniert:

#include <stdio.h> 
#include <stdlib.h> 

int main (int argc, char *argv[]) 
{ 
    char c1, c2, c3; 

    c1 = 'A'; /* ascii value of 65 */ 
    c2 = 'd'; /* ascii value of 100 */ 

    printf("decimal value of c1 and c2 is %d and %d\n", c1, c2); 

    if ((c1 >= 65) && (c1 <= 90)) 
    { 
     printf("I know c1 contains a letter between capital A and capital Z,\n"); 
     printf("it's decimal value is %d which is the character %c\n", c1, c1); 
    } 


    c1 = 'A'; /* ascii 65 */ 
    c2 = 'a'; /* ascii 97 */ 
    c3 = c2 - c1; 
    printf("c1 = %c, c2 = %c\n", c1, c2); 
    printf(" c2 - c1 = %d, x%cx\n", c3, c3); 

    /* ascii of 97-65 = 32 == space character */ 

    c1 = 67; /* set c1 to a capital C */ 
    printf(" c1 = decimal %d, it is character %c\n", c1, c1); 

    return 0; 
} 

http://www.asciitable.com/

Answer 5

Mit C99, kann Code verwenden zusammengesetzte Literale. Code erstellt zwei 3-char-Arrays und füllt sie mit Elementen von atr[].

const char* atr = "abcd"; 

char* _ts = (char [3]) {atr[0], atr[1], '\0'}; 
char* _t0 = (char [3]) {atr[2], atr[3], '\0'}; 

puts(_ts); 
puts(_t0); 

Ausgabe

ab 
cd 

Die Zeiger _ts, _t0 sind bis zum Ende des Blocks gültig.