メモリ操作

[C言語] memcpy関数の使い方をわかりやすく詳しく解説

2025-01-19更新日: 2025-01-19

memcpy関数は、C言語の標準ライブラリ関数で、指定したソースメモリ領域からデスティネーション領域へnバイト分のデータを高速にコピーします。

シンタックスは memcpy(dest, src, n) で、destにsrcからnバイトをコピーします。

主に配列や構造体のコピーに使用されますが、コピー元とコピー先が重なる場合は未定義動作となるため、重なる可能性がある場合はmemmove関数を使用する必要があります。

使用時にはコピー先のメモリ領域が十分に確保されていることを確認してください。

目次から探す
  1. memcpy関数とは
  2. memcpy関数の基本的な使い方
  3. memcpy関数の使用例
  4. memcpy関数を使用する際の注意点
  5. まとめ

memcpy関数とは

memcpy関数は、C言語においてメモリブロックを効率的にコピーするための標準ライブラリ関数です。

主に、あるメモリ領域から別のメモリ領域へ指定したバイト数のデータを高速に転送する際に使用されます。

memcpyは<string.h>ヘッダーファイルに定義されており、多くのプログラムで広く利用されています。

基本的な概要

  • ヘッダーファイル: <string.h>
  • 関数プロトタイプ:
void *memcpy(void *dest, const void *src, size_t n);
  • 引数:
    • dest：コピー先のメモリブロックへのポインタ。
    • src：コピー元のメモリブロックへのポインタ。
    • n：コピーするバイト数。

動作の仕組み

memcpy関数は、srcで指定されたメモリ領域からdestで指定されたメモリ領域へと、nバイト分のデータを連続してコピーします。

この操作は、バイト単位で行われるため、構造体や配列などの複雑なデータ構造のコピーにも適しています。

戻り値

memcpy関数は、コピー先のポインタdestを返します。

これにより、関数を連続して呼び出すチェーン処理や、コピー後のポインタ操作が可能になります。

注意点

  • オーバーラップの回避：memcpyは、コピー元とコピー先のメモリ領域が重なる場合の動作が未定義です。重なりが生じる可能性がある場合は、memmove関数の使用が推奨されます。
  • バイト数の正確な指定：コピーするバイト数nを正確に指定しないと、バッファのオーバーフローや不足が発生する可能性があります。

使用例

以下に、memcpy関数を使用して文字列データをコピーする簡単な例を示します。

#include <stdio.h>
#include <string.h>
int main() {
    char source[] = "こんにちは、世界！"; // コピー元の文字列
    char destination[50]; // コピー先のバッファ
    // sourceからdestinationへ文字列全体をコピー
    memcpy(destination, source, sizeof(source));
    // コピー後の内容を表示
    printf("コピー後のdestination: %s\n", destination);
    return 0;
}
コピー後のdestination: こんにちは、世界！

この例では、source配列に格納された日本語の文字列をdestination配列にコピーしています。

sizeof(source)を使用することで、文字列全体のバイト数を正確に指定しています。

実行結果として、destinationにコピーされた文字列が正しく表示されます。

memcpy関数の基本的な使い方

memcpy関数を正しく使用するためには、その基本的な使い方を理解することが重要です。

ここでは、memcpy関数の基本的な使用方法について詳しく説明します。

基本的な構文

memcpy関数の基本的な構文は以下の通りです。

void *memcpy(void *dest, const void *src, size_t n);
  • dest：コピー先のメモリ領域を指すポインタ。
  • src：コピー元のメモリ領域を指すポインタ。
  • n：コピーするバイト数。

使用手順

  1. 必要なヘッダーのインクルード

memcpy関数を使用するためには、<string.h>ヘッダーをインクルードする必要があります。

  1. コピー元とコピー先のメモリ領域を準備

コピー元のデータが格納されているメモリ領域と、コピー先のメモリ領域を確保します。

  1. memcpy関数を呼び出す

memcpy関数にコピー先、コピー元、コピーするバイト数を引数として渡します。

以下に、memcpy関数を使用して整数配列をコピーする例を示します。

#include <stdio.h>
#include <string.h>
int main() {
    int sourceArray[] = {1, 2, 3, 4, 5}; // コピー元の配列
    int destinationArray[5]; // コピー先の配列
    // sourceArrayからdestinationArrayへ配列全体をコピー
    memcpy(destinationArray, sourceArray, sizeof(sourceArray));
    // コピー後の内容を表示
    printf("コピー後のdestinationArray: ");
    for(int i = 0; i < 5; i++) {
        printf("%d ", destinationArray[i]);
    }
    printf("\n");
    return 0;
}
コピー後のdestinationArray: 1 2 3 4 5

上記の例では、sourceArrayに格納された整数配列をdestinationArrayにコピーしています。

sizeof(sourceArray)を使用することで、配列全体のバイト数を正確に指定しています。

memcpy関数を使用することで、配列の全要素を一度に効率的にコピーすることができます。

コピー後、destinationArrayの内容をループで表示し、正しくコピーされたことを確認しています。

重要なポイント

  • バイト数の正確な指定

コピーするバイト数nは、コピー元のデータ全体を正確にカバーする必要があります。

配列の場合、sizeof配列名を使用すると便利です。

  • メモリ領域の確保

コピー先のメモリ領域は、コピー元と同じサイズ以上のメモリが確保されていることを確認してください。

不十分なメモリ領域は、未定義の動作やプログラムのクラッシュを引き起こす可能性があります。

  • データ型の一致

コピー元とコピー先のデータ型が一致していることを確認してください。

異なるデータ型間でのコピーは、予期しない動作を引き起こすことがあります。

memcpy関数を使用する際には、これらのポイントに注意しながら、正確かつ安全にメモリ操作を行うことが重要です。

memcpy関数の使用例

memcpy関数は、さまざまなデータ型やデータ構造のメモリコピーに利用されます。

ここでは、具体的な使用例をいくつか紹介し、memcpyの実際の活用方法を理解していきます。

配列のコピー

配列は、memcpyを使用して効率的にコピーする代表的なデータ構造です。

以下の例では、整数型の配列を別の配列にコピーしています。

#include <stdio.h>
#include <string.h>
int main() {
    int sourceArray[] = {10, 20, 30, 40, 50}; // コピー元の配列
    int destinationArray[5]; // コピー先の配列
    // sourceArrayからdestinationArrayへ配列全体をコピー
    memcpy(destinationArray, sourceArray, sizeof(sourceArray));
    // コピー後の内容を表示
    printf("コピー後のdestinationArray: ");
    for(int i = 0; i < 5; i++) {
        printf("%d ", destinationArray[i]);
    }
    printf("\n");
    return 0;
}
コピー後のdestinationArray: 10 20 30 40 50

構造体のコピー

構造体は、複数の異なるデータ型をまとめたデータ構造です。

memcpyを使用して構造体全体をコピーすることができます。

#include <stdio.h>
#include <string.h>
// 人物を表す構造体
typedef struct {
    char name[50];
    int age;
    double height;
} Person;
int main() {
    Person sourcePerson = {"田中 太郎", 30, 175.5}; // コピー元の構造体
    Person destinationPerson; // コピー先の構造体
    // sourcePersonからdestinationPersonへ構造体全体をコピー
    memcpy(&destinationPerson, &sourcePerson, sizeof(Person));
    // コピー後の内容を表示
    printf("コピー後のdestinationPerson:\n");
    printf("名前: %s\n", destinationPerson.name);
    printf("年齢: %d\n", destinationPerson.age);
    printf("身長: %.1lf cm\n", destinationPerson.height);
    return 0;
}
コピー後のdestinationPerson:
名前: 田中 太郎
年齢: 30
身長: 175.5 cm

文字列のコピー

文字列は、文字の配列として扱われます。

memcpyを使用して文字列をコピーすることも可能ですが、通常はstrcpyやstrncpyが使用されます。

ここではmemcpyを使用した例を示します。

#include <stdio.h>
#include <string.h>
int main() {
    char sourceString[] = "こんにちは、C言語！"; // コピー元の文字列
    char destinationString[50]; // コピー先のバッファ
    // sourceStringからdestinationStringへ文字列全体をコピー
    memcpy(destinationString, sourceString, sizeof(sourceString));
    // コピー後の内容を表示
    printf("コピー後のdestinationString: %s\n", destinationString);
    return 0;
}
コピー後のdestinationString: こんにちは、C言語！

バッファの部分コピー

memcpyは、データの一部をコピーする際にも有効です。

以下の例では、配列の一部を別の配列にコピーしています。

#include <stdio.h>
#include <string.h>
int main() {
    char sourceBuffer[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // コピー元のバッファ
    char destinationBuffer[10]; // コピー先のバッファ
    // sourceBufferの先頭から10バイトをdestinationBufferへコピー
    memcpy(destinationBuffer, sourceBuffer, 10);
    // コピー後の内容を表示
    destinationBuffer[9] = '\0'; // 終端文字を追加
    printf("コピー後のdestinationBuffer: %s\n", destinationBuffer);
    return 0;
}
コピー後のdestinationBuffer: ABCDEFGHIJ

多次元配列のコピー

memcpyは、多次元配列のコピーにも利用できます。

以下の例では、2次元配列を別の2次元配列にコピーしています。

#include <stdio.h>
#include <string.h>
int main() {
    int sourceMatrix[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    }; // コピー元の2次元配列
    int destinationMatrix[2][3]; // コピー先の2次元配列
    // sourceMatrixからdestinationMatrixへ2次元配列全体をコピー
    memcpy(destinationMatrix, sourceMatrix, sizeof(sourceMatrix));
    // コピー後の内容を表示
    printf("コピー後のdestinationMatrix:\n");
    for(int i = 0; i < 2; i++) {
        for(int j = 0; j < 3; j++) {
            printf("%d ", destinationMatrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}
コピー後のdestinationMatrix:
1 2 3
4 5 6

動的メモリのコピー

動的に確保したメモリ領域間でもmemcpyを使用してデータをコピーできます。

以下の例では、mallocを使用して動的に配列を確保し、その内容をコピーしています。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() {
    // コピー元の動的メモリ
    char *source = (char *)malloc(20 * sizeof(char));
    strcpy(source, "動的メモリのコピー");
    // コピー先の動的メモリ
    char *destination = (char *)malloc(20 * sizeof(char));
    // sourceからdestinationへメモリをコピー
    memcpy(destination, source, strlen(source) + 1); // 終端文字もコピー
    // コピー後の内容を表示
    printf("コピー後のdestination: %s\n", destination);
    // メモリの解放
    free(source);
    free(destination);
    return 0;
}
コピー後のdestination: 動的メモリのコピー

配列とポインタの組み合わせ

memcpyは、配列とポインタを組み合わせて使用する際にも有用です。

以下の例では、ポインタを使用して配列の一部をコピーしています。

#include <stdio.h>
#include <string.h>
int main() {
    char sourceArray[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // コピー元の配列
    char destinationArray[10]; // コピー先の配列
    char *srcPtr = sourceArray + 5; // 'F'から始まるポインタ
    // srcPtrからdestinationArrayへ10バイトをコピー
    memcpy(destinationArray, srcPtr, 10);
    // コピー後の内容を表示
    destinationArray[9] = '\0'; // 終端文字を追加
    printf("コピー後のdestinationArray: %s\n", destinationArray);
    return 0;
}
コピー後のdestinationArray: FGHIJKLMN

構造体内の配列のコピー

構造体内に配列が含まれている場合でも、memcpyを使用して部分的にデータをコピーすることができます。

以下の例では、構造体内の配列部分を別の配列にコピーしています。

#include <stdio.h>
#include <string.h>
// データを保持する構造体
typedef struct {
    int id;
    char data[20];
} DataContainer;
int main() {
    DataContainer source = {1001, "構造体内のデータ"}; // コピー元の構造体
    char destinationData[20]; // コピー先の配列
    // sourceのdata配列からdestinationDataへコピー
    memcpy(destinationData, source.data, sizeof(source.data));
    // コピー後の内容を表示
    printf("コピー後のdestinationData: %s\n", destinationData);
    return 0;
}
コピー後のdestinationData: 構造体内のデータ

これらの使用例を通じて、memcpy関数がさまざまなシナリオでどのように活用できるかを理解することができます。

配列、構造体、動的メモリなど、異なるデータ構造間での効率的なデータコピーを実現するために、memcpyは非常に有用なツールです。

ただし、前述の注意点を踏まえて、安全かつ正確に使用することが重要です。

memcpy関数を使用する際の注意点

memcpy関数は強力なメモリコピー機能を提供しますが、正しく使用しないと予期しない動作やセキュリティ上の問題を引き起こす可能性があります。

ここでは、memcpy関数を使用する際に留意すべき主な注意点について詳しく解説します。

メモリ領域のオーバーラップに注意

memcpy関数は、コピー元とコピー先のメモリ領域が重なる場合に未定義の動作を引き起こします。

メモリ領域が重なる可能性がある場合は、memmove関数を使用することが推奨されます。

間違った使用例

#include <stdio.h>
#include <string.h>
int main() {
    char buffer[] = "Hello, World!";
    // コピー元とコピー先がオーバーラップしている
    memcpy(buffer + 7, buffer, 6);
    printf("結果: %s\n", buffer);
    return 0;
}
結果: Hello, Hello!

この例では、buffer内でソースとデスティネーションがオーバーラップしているため、予期しない結果となります。

正しくはmemmoveを使用すべきです。

正しい使用例

#include <stdio.h>
#include <string.h>
int main() {
    char buffer[] = "Hello, World!";
    // オーバーラップするメモリ領域をコピーする際はmemmoveを使用
    memmove(buffer + 7, buffer, 6);
    printf("結果: %s\n", buffer);
    return 0;
}
結果: Hello, Hello!

memmoveを使用することで、オーバーラップが発生しても正しくデータがコピーされます。

コピーするバイト数の正確な指定

memcpy関数は指定したバイト数だけメモリをコピーします。

不適切なバイト数指定は、バッファオーバーフローや不足を引き起こし、プログラムのクラッシュやセキュリティホールにつながる可能性があります。

間違った使用例

#include <stdio.h>
#include <string.h>
int main() {
    int sourceArray[] = {1, 2, 3, 4, 5};
    int destinationArray[3]; // 十分なサイズが確保されていない
    // コピーするバイト数が大きすぎる
    memcpy(destinationArray, sourceArray, sizeof(sourceArray));
    // コピー後の内容を表示(未定義動作の可能性あり)
    for(int i = 0; i < 5; i++) {
        printf("%d ", destinationArray[i]);
    }
    printf("\n");
    return 0;
}
プログラムがクラッシュする可能性があります。

この例では、destinationArrayのサイズがsourceArrayに比べて小さいため、バッファオーバーフローが発生します。

正しい使用例

#include <stdio.h>
#include <string.h>
int main() {
    int sourceArray[] = {1, 2, 3, 4, 5};
    int destinationArray[5]; // 十分なサイズを確保
    // 正確なバイト数を指定
    memcpy(destinationArray, sourceArray, sizeof(sourceArray));
    // コピー後の内容を表示
    printf("コピー後のdestinationArray: ");
    for(int i = 0; i < 5; i++) {
        printf("%d ", destinationArray[i]);
    }
    printf("\n");
    return 0;
}
コピー後のdestinationArray: 1 2 3 4 5

sizeof(sourceArray)を使用することで、正確なバイト数が指定され、バッファオーバーフローを回避できます。

データ型の整合性を確保

memcpyはバイト単位でのコピーを行うため、コピー元とコピー先のデータ型が一致している必要があります。

異なるデータ型間でのコピーは、データの解釈に誤りを生じさせる可能性があります。

間違った使用例

#include <stdio.h>
#include <string.h>
int main() {
    double source = 3.14159;
    int destination;
    // 異なるデータ型間でのコピー
    memcpy(&destination, &source, sizeof(source));
    printf("コピー後のdestination: %d\n", destination);
    return 0;
}
コピー後のdestination: 1078523331

この例では、double型からint型へのコピーが行われており、意味のある結果が得られません。

正しい使用例

#include <stdio.h>
#include <string.h>
int main() {
    int source = 100;
    int destination;
    // 同じデータ型間でのコピー
    memcpy(&destination, &source, sizeof(source));
    printf("コピー後のdestination: %d\n", destination);
    return 0;
}
コピー後のdestination: 100

データ型を一致させることで、正確なコピーが実現します。

ポインタのコピーに注意

memcpyを使用してポインタ自体をコピーすると、ポインタが指す先のデータではなく、ポインタのアドレスがコピーされます。

これにより、浅いコピー(シャローコピー)が行われ、元のデータとコピー先のデータが同じメモリを参照することになります。

浅いコピーの例

#include <stdio.h>
#include <string.h>
typedef struct {
    int id;
    char *name;
} Person;
int main() {
    Person source = {1, "Alice"};
    Person destination;
    // ポインタの浅いコピー
    memcpy(&destination, &source, sizeof(source));
    // コピー後の内容を表示
    printf("コピー後のdestination:\n");
    printf("ID: %d\n", destination.id);
    printf("名前: %s\n", destination.name);
    // sourceとdestinationのnameが同じメモリを指している
    return 0;
}
コピー後のdestination:
ID: 1
名前: Alice

この場合、source.nameとdestination.nameは同じ文字列リテラルを指しています。

文字列を変更すると、両方に影響を及ぼします。

深いコピーの例

ポインタが指すデータ自体をコピーしたい場合は、手動でメモリを割り当ててデータをコピーする必要があります。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
    int id;
    char *name;
} Person;
int main() {
    Person source;
    source.id = 1;
    source.name = strdup("Alice"); // 動的にメモリを割り当て
    Person destination;
    destination.id = 0;
    destination.name = malloc(strlen(source.name) + 1); // 必要なメモリを確保
    // 深いコピー
    memcpy(&destination, &source, sizeof(Person));
    memcpy(destination.name, source.name, strlen(source.name) + 1);
    // コピー後の内容を表示
    printf("コピー後のdestination:\n");
    printf("ID: %d\n", destination.id);
    printf("名前: %s\n", destination.name);
    // メモリの解放
    free(source.name);
    free(destination.name);
    return 0;
}
コピー後のdestination:
ID: 1
名前: Alice

この例では、nameフィールド自体を別途コピーすることで、浅いコピーではなく深いコピーを実現しています。

メモリの有効範囲を確認

memcpyでコピー先のメモリ領域が有効な範囲内であることを確認する必要があります。

無効なメモリ領域への書き込みは、プログラムのクラッシュやセキュリティ上の脆弱性を引き起こす可能性があります。

注意すべき点

  • スタック領域: 配列がスタック上にある場合、サイズを超えるコピーはスタック破壊を引き起こします。
  • ヒープ領域: 動的に割り当てたメモリの場合、mallocやcallocで十分なサイズを確保していることを確認します。
  • ポインタの有効性: コピー先のポインタがNULLでないこと、または適切に初期化されていることを確認します。

エラーチェックの例

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main() {
    char *source = "安全なコピー操作";
    size_t copySize = strlen(source) + 1;
    // コピー先のメモリを動的に割り当て
    char *destination = malloc(copySize);
    if(destination == NULL) {
        fprintf(stderr, "メモリの割り当てに失敗しました。\n");
        return 1;
    }
    // memcpyを安全に使用
    memcpy(destination, source, copySize);
    printf("コピー後のdestination: %s\n", destination);
    // メモリの解放
    free(destination);
    return 0;
}
コピー後のdestination: 安全なコピー操作

この例では、mallocの失敗をチェックし、安全にメモリをコピーしています。

アライメントの考慮

特定のハードウェアアーキテクチャでは、メモリのアライメント(配置)が要求されます。

不適切なアライメントは、パフォーマンスの低下やハードウェア例外を引き起こす可能性があります。

memcpyを使用する際は、データが適切にアラインされていることを確認してください。

アライメント違反の例

#include <stdio.h>
#include <string.h>
int main() {
    char buffer[10];
    int *intPtr = (int *)(buffer + 1); // アライメントが崩れる
    int value = 12345;
    // アライメントが崩れたメモリにコピー
    memcpy(intPtr, &value, sizeof(value));
    printf("コピー後の値: %d\n", *intPtr);
    return 0;
}
コピー後の値: 12345

このコードは動作する場合もありますが、アーキテクチャによってはクラッシュや未定義動作を引き起こす可能性があります。

特に、アライメントが厳格な環境(例: 一部の組み込みシステム)では注意が必要です。

アライメントを守るための対策

  • 適切なメモリアロケーション: mallocやcallocは適切なアライメントを保証します。手動でアロケートする場合は、アライメントを考慮した方法を使用します。
  • 構造体のパディング: 構造体内のメンバーの順序を調整して、自然なアライメントを確保します。

パフォーマンスへの影響

memcpyは大量のデータをコピーする際に非常に効率的ですが、小さなデータを頻繁にコピーすると、オーバーヘッドがパフォーマンスに影響を与えることがあります。

必要に応じて、データ構造の設計を見直すことが推奨されます。

パフォーマンス最適化の例

#include <stdio.h>
#include <string.h>
#include <time.h>
#define ITERATIONS 1000000
#define DATA_SIZE 64
int main() {
    char source[DATA_SIZE];
    char destination[DATA_SIZE];
    memset(source, 'A', DATA_SIZE);
    clock_t start = clock();
    for(int i = 0; i < ITERATIONS; i++) {
        memcpy(destination, source, DATA_SIZE);
    }
    clock_t end = clock();
    double timeSpent = (double)(end - start) / CLOCKS_PER_SEC;
    printf("memcpyを%d回実行するのにかかった時間: %.6lf秒\n", ITERATIONS, timeSpent);
    return 0;
}
memcpyを1000000回実行するのにかかった時間: 0.050000秒

この例では、memcpyを大量に実行した際のパフォーマンスを測定しています。

最適化が必要な場合は、アルゴリズムの見直しやメモリアクセスパターンの改善を検討します。

セキュリティ上の考慮

不適切なmemcpyの使用は、バッファオーバーフローやデータ漏洩などのセキュリティ脆弱性を引き起こす可能性があります。

以下の点に注意して、安全なコーディングを心がけましょう。

  • 入力データの検証: 外部からの入力データをコピーする前に、サイズや内容を検証します。
  • 境界チェック: コピー先のバッファサイズを確認し、オーバーフローを防ぎます。
  • 安全な代替関数の検討: 一部の環境では、memcpyよりも安全なコピー関数(例: memcpy_s)が提供されています。可能であれば、これらを使用します。

セキュリティ対策の例

#include <stdio.h>
#include <string.h>
int main() {
    char source[] = "安全なメモリコピー";
    char destination[10];
    size_t sourceLength = strlen(source) + 1; // 終端文字も含む
    if(sourceLength > sizeof(destination)) {
        fprintf(stderr, "エラー: コピー先のバッファが小さすぎます。\n");
        return 1;
    }
    memcpy(destination, source, sourceLength);
    printf("コピー後のdestination: %s\n", destination);
    return 0;
}
エラー: コピー先のバッファが小さすぎます。

この例では、コピー前にソースデータのサイズをチェックし、安全性を確保しています。

memcpy関数は非常に便利で強力なメモリコピー手段ですが、以下の注意点を守ることで、安全かつ効果的に使用することができます。

  1. メモリ領域のオーバーラップに注意し、必要に応じてmemmoveを使用する。
  2. コピーするバイト数を正確に指定し、バッファサイズを確認する。
  3. データ型の整合性を保ち、ポインタのコピーには注意する。
  4. メモリのアライメントを考慮し、適切なメモリアロケーションを行う。
  5. パフォーマンスへの影響を理解し、最適な使用方法を選択する。
  6. セキュリティ上のリスクを認識し、適切な対策を講じる。

これらのポイントを踏まえてmemcpyを使用することで、効率的かつ安全なプログラムの実装が可能になります。

まとめ

本記事ではC言語におけるmemcpy関数の機能と使用方法について詳しく説明しました。

memcpy関数は効率的なメモリ操作を実現し、さまざまなデータ構造のコピーに役立ちます。

ぜひ実際のプロジェクトでmemcpy関数を活用して、プログラムのパフォーマンス向上を図ってください。

2025-01-19更新日: 2025-01-19

関連記事

[C言語] memsetの処理を高速化する方法

[C言語] memsetの処理を高速化する方法

2025-01-17
[C言語] mallocとcallocの違いについて

[C言語] mallocとcallocの違いについて

2025-01-18
[C言語] memset関数とmemcpy関数の違いについて解説

[C言語] memset関数とmemcpy関数の違いについて解説

2025-01-17
[C言語] 初期化に使うmemset関数の使い方を詳しく解説

[C言語] 初期化に使うmemset関数の使い方を詳しく解説

2025-01-18
[C言語] mallocで確保したメモリをfreeで解放しないリスクとは？

[C言語] mallocで確保したメモリをfreeで解放しないリスクとは？

2025-01-17
[C言語] malloc関数を使って文字列を初期化する

[C言語] malloc関数を使って文字列を初期化する

2025-01-18
[C言語] calloc関数の使い方 – メモリの動的確保&0初期化

【C言語】callocの使い方：動的メモリ割り当てとメモリの初期化

2025-01-21
[C言語] null判定する方法をわかりやすく詳しく解説

[C言語] null判定する方法をわかりやすく詳しく解説

2025-01-18
[C言語] mallocで確保されたメモリをfree関数で解放する

[C言語] mallocで確保されたメモリをfree関数で解放する

2025-01-18
[C言語] malloc関数を使って動的に配列を生成する方法を解説

[C言語] malloc関数を使って動的に配列を生成する方法を解説

2025-01-18
Back to top button