【C言語】文字列リテラルとchar配列とは？違いと使い分けをやさしく解説

char s[4] = "abc";

#include <stdio.h>

int main(void) {
    char *p = "abc";      // 文字列リテラルへのポインタ
    printf("%s\n", p);

    // 文字列リテラルを書き換えようとする(危険)
    p[0] = 'A';           // ここで未定義動作になる

    printf("%s\n", p);
    return 0;
}

#include <stdio.h>

int main(void) {
    // char配列を文字列リテラルから初期化
    char s[] = "abc";

    printf("初期値: %s\n", s);

    // 配列の中身を書き換える(安全)
    s[0] = 'A';
    s[1] = 'B';
    s[2] = 'C';

    printf("書き換え後: %s\n", s);

    return 0;
}

#include <stdio.h>
#include <string.h>

int main(void) {
    char s[] = "abc";   // 配列
    char *p = "abc";    // 文字列リテラルへのポインタ

    printf("sizeof(s)  = %zu\n", sizeof(s));
    printf("strlen(s)  = %zu\n", strlen(s));
    printf("sizeof(p)  = %zu\n", sizeof(p));
    printf("strlen(p)  = %zu\n", strlen(p));

    return 0;
}

sizeof(s)  = 4
strlen(s)  = 3
sizeof(p)  = 8
strlen(p)  = 3

#include <stdio.h>

int main(void) {
    // 1. 文字列リテラルから配列を初期化
    char s1[] = "abc";          // 要素数は4になる("a","b","c","
#include <stdio.h>
int main(void) {
// 1. 文字列リテラルから配列を初期化
char s1[] = "abc";          // 要素数は4になる("a","b","c","\0")
// 2. 要素数を明示して初期化
char s2[4] = "abc";         // これも "a","b","c","\0"
// 3. 要素を個別に指定して初期化
char s3[4] = { 'a', 'b', 'c', '\0' };
// 4. ポインタに文字列リテラルのアドレスを代入
char *p = "abc";            // pは読み取り専用の"abc"を指す
printf("s1: %s\n", s1);
printf("s2: %s\n", s2);
printf("s3: %s\n", s3);
printf("p:  %s\n", p);
return 0;
}
")

    // 2. 要素数を明示して初期化
    char s2[4] = "abc";         // これも "a","b","c","
#include <stdio.h>
int main(void) {
// 1. 文字列リテラルから配列を初期化
char s1[] = "abc";          // 要素数は4になる("a","b","c","\0")
// 2. 要素数を明示して初期化
char s2[4] = "abc";         // これも "a","b","c","\0"
// 3. 要素を個別に指定して初期化
char s3[4] = { 'a', 'b', 'c', '\0' };
// 4. ポインタに文字列リテラルのアドレスを代入
char *p = "abc";            // pは読み取り専用の"abc"を指す
printf("s1: %s\n", s1);
printf("s2: %s\n", s2);
printf("s3: %s\n", s3);
printf("p:  %s\n", p);
return 0;
}
"

    // 3. 要素を個別に指定して初期化
    char s3[4] = { 'a', 'b', 'c', '
#include <stdio.h>
int main(void) {
// 1. 文字列リテラルから配列を初期化
char s1[] = "abc";          // 要素数は4になる("a","b","c","\0")
// 2. 要素数を明示して初期化
char s2[4] = "abc";         // これも "a","b","c","\0"
// 3. 要素を個別に指定して初期化
char s3[4] = { 'a', 'b', 'c', '\0' };
// 4. ポインタに文字列リテラルのアドレスを代入
char *p = "abc";            // pは読み取り専用の"abc"を指す
printf("s1: %s\n", s1);
printf("s2: %s\n", s2);
printf("s3: %s\n", s3);
printf("p:  %s\n", p);
return 0;
}
' };

    // 4. ポインタに文字列リテラルのアドレスを代入
    char *p = "abc";            // pは読み取り専用の"abc"を指す

    printf("s1: %s\n", s1);
    printf("s2: %s\n", s2);
    printf("s3: %s\n", s3);
    printf("p:  %s\n", p);

    return 0;
}

s1: abc
s2: abc
s3: abc
p:  abc

#include <stdio.h>

int main(void) {
    // 文字列リテラルへのポインタ
    char *p = "hello";

    // ここで文字列を大文字に変換したいとする
    for (int i = 0; p[i] != '
#include <stdio.h>
int main(void) {
// 文字列リテラルへのポインタ
char *p = "hello";
// ここで文字列を大文字に変換したいとする
for (int i = 0; p[i] != '\0'; i++) {
if ('a' <= p[i] && p[i] <= 'z') {
p[i] = p[i] - 'a' + 'A';  // ここが危険
}
}
printf("%s\n", p);
return 0;
}
'; i++) {
        if ('a' <= p[i] && p[i] <= 'z') {
            p[i] = p[i] - 'a' + 'A';  // ここが危険
        }
    }

    printf("%s\n", p);
    return 0;
}

#include <stdio.h>

int main(void) {
    // 書き換え可能な配列として確保
    char s[] = "hello";

    for (int i = 0; s[i] != '
#include <stdio.h>
int main(void) {
// 書き換え可能な配列として確保
char s[] = "hello";
for (int i = 0; s[i] != '\0'; i++) {
if ('a' <= s[i] && s[i] <= 'z') {
s[i] = s[i] - 'a' + 'A';  // 安全に書き換え可能
}
}
printf("%s\n", s);
return 0;
}
'; i++) {
        if ('a' <= s[i] && s[i] <= 'z') {
            s[i] = s[i] - 'a' + 'A';  // 安全に書き換え可能
        }
    }

    printf("%s\n", s);
    return 0;
}

const char *p = "abc";

#include <stdio.h>

// 文字列を表示するだけで、中身を書き換えない関数
void show_message(const char *msg) {
    printf("メッセージ: %s\n", msg);
    // msg[0] = 'X';  // これはコンパイルエラーになる
}

int main(void) {
    show_message("Hello");
    return 0;
}

#include <stdio.h>

int main(void) {
    // サイズ3の配列に"abc"を入れようとすると…
    char s[3] = "abc";  // 実は危険なコード

    printf("%s\n", s);  // 未定義動作の可能性

    return 0;
}

#include <stdio.h>

int main(void) {
    char s[4] = "abc";  // 正しい: "a","b","c","
#include <stdio.h>
int main(void) {
char s[4] = "abc";  // 正しい: "a","b","c","\0" の4文字が入る
printf("%s\n", s);  // 安全に表示できる
return 0;
}
" の4文字が入る

    printf("%s\n", s);  // 安全に表示できる

    return 0;
}

#include <stdio.h>

int main(void) {
    char s[] = "abc";   // 配列
    char *p  = s;       // 配列の先頭要素を指すポインタ

    printf("s[0] = %c, p[0] = %c\n", s[0], p[0]);

    // sとpは似て見えるが…
    printf("sizeof(s) = %zu\n", sizeof(s));  // 配列全体のサイズ
    printf("sizeof(p) = %zu\n", sizeof(p));  // ポインタのサイズ

    // pは別の文字列を指すこともできる
    p = "xyz";  // pの指す先を変更(ただし書き換え禁止の領域)

    printf("p: %s\n", p);

    return 0;
}

void func(char s[]);
void func(char *s);

#include <stdio.h>

// 引数を配列風に書いた例
void print1(char s[]) {
    printf("print1: %s\n", s);
}

// 引数をポインタとして書いた例
void print2(char *s) {
    printf("print2: %s\n", s);
}

int main(void) {
    char msg[] = "hello";

    print1(msg);  // 配列の先頭アドレスが渡される
    print2(msg);  // 同じく先頭アドレスが渡される

    return 0;
}

void print_message(const char *s);

#include <stdio.h>
#include <string.h>

// 文字列をその場で逆順にする関数
void reverse_string(char s[]) {
    int len = (int)strlen(s);
    for (int i = 0; i < len / 2; i++) {
        char tmp = s[i];
        s[i] = s[len - 1 - i];
        s[len - 1 - i] = tmp;
    }
}

int main(void) {
    // 書き換え可能な配列として十分なサイズを用意
    char s[100] = "hello";

    printf("before: %s\n", s);
    reverse_string(s);
    printf("after:  %s\n", s);

    return 0;
}

#include <stdio.h>

int main(void) {
    // 変更しない文字列は文字列リテラル＋constポインタで十分
    const char *msg = "処理が完了しました。";

    printf("%s\n", msg);

    // msg[0] = 'A';  // コンパイルエラーになるので安心

    return 0;
}