C言語を楽しく学ぼう!初心者でも理解できるSwap関数の使い方とサンプルコード10選

C言語のSwap関数を初心者が理解しやすいように解説した図C言語
この記事は約23分で読めます。

【サイト内のコードはご自由に個人利用・商用利用いただけます】

この記事では、プログラムの基礎知識を前提に話を進めています。

説明のためのコードや、サンプルコードもありますので、もちろん初心者でも理解できるように表現してあります。

基本的な知識があればサンプルコードを活用して機能追加、目的を達成できるように作ってあります。

※この記事は、一般的にプロフェッショナルの指標とされる『実務経験10,000時間以上』を凌駕する現役のプログラマチームによって監修されています。

サイト内のコードを共有する場合は、参照元として引用して下さいますと幸いです

※Japanシーモアは、常に解説内容のわかりやすさや記事の品質に注力しております。不具合、分かりにくい説明や不適切な表現、動かないコードなど気になることがございましたら、記事の品質向上の為にお問い合わせフォームにてご共有いただけますと幸いです。
(送信された情報は、プライバシーポリシーのもと、厳正に取扱い、処分させていただきます。)

はじめに

皆さんこんにちは。

今回はプログラミング言語の基本となるC言語について、特にSwap関数の使い方とその具体的なサンプルコードを詳しく解説していきたいと思います。

C言語をこれから学びたい初心者の方でもすぐに理解して利用できるよう、理論から具体的な使用例までを詳細に説明します。

●C言語とSwap関数の基本

○C言語について

C言語はプログラミング言語の一つで、システムプログラミングを行う際に広く利用されています。

多くの現代のプログラミング言語はC言語から派生したものであり、C言語を理解することは他の言語を学ぶ際の基礎となります。

○Swap関数とは何か

Swap関数は、その名の通り、2つの変数の値を交換する関数です。

C言語におけるこの関数はプログラミング初学者にとって重要な学習材料であり、プログラミングの基礎を理解する上で非常に有用です。

●Swap関数の使い方

○基本的なSwap関数の形

Swap関数の基本形は次のようになります。

void swap(int *a, int *b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

このコードでは、引数として2つのポインタを取り、それらの指す変数の値を交換します。

tempという一時変数を用いて値を一時的に保存し、その後で値の交換を行います。

○引数とは何か

引数とは、関数に渡す値のことを指します。

上記の例では、swap関数に渡す引数は2つのポインタです。

○Swap関数の実行

先ほどのSwap関数を使用して2つの変数の値を交換するためのコードを書くと、次のようになります。

int main() {
    int x = 10, y = 20;
    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

このコードを実行すると、xとyの値が交換された結果が出力されます。

Before swap: x = 10, y = 20
After swap: x = 20, y = 10

つまり、swap関数が呼び出されると、xとyの値が互いに交換されることがわかります。

●Swap関数のサンプルコード

ここで、Swap関数の具体的な使用例を10個紹介します。

これらの例から、初心者でもSwap関数の使い方を理解し、自分のプログラムに適用できるようになることでしょう。

○サンプルコード1:基本的なSwap

このコードでは、一番基本的なSwap関数の形を表しています。

この例では、二つの整数変数aとbの値を交換しています。

#include<stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int a = 5, b = 10;
    printf("元の値:a = %d, b = %d\n", a, b);
    swap(&a, &b);
    printf("Swap後の値:a = %d, b = %d", a, b);
    return 0;
}

このプログラムを実行すると、以下の結果が得られます。

元の値:a = 5, b = 10
Swap後の値:a = 10, b = 5

これはSwap関数が正しく動作して、aとbの値が交換されていることを示しています。

○サンプルコード2:配列の要素のSwap

次のサンプルコードでは、配列の要素をSwap関数を使って交換します。

この例では、1つ目と2つ目の要素を交換しています。

#include<stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int array[5] = {1, 2, 3, 4, 5};
    printf("元の配列:");
    for(int i=0; i<5; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
    swap(&array[0], &array[1]);
    printf("Swap後の配列:");
    for(int i=0; i<5; i++) {
        printf("%d ", array[i]);
    }
    return 0;
}

このプログラムを実行すると、次の結果が得られます。

元の配列:1 2 3 4 5 
Swap後の配列:2 1 3 4 5

これは、配列の1つ目と2つ目の要素が正しく交換されていることを表しています。

○サンプルコード3:構造体のSwap

まずは、構造体を交換するSwap関数の例を見てみましょう。

C言語における構造体は、複数の変数をひとつにまとめて取り扱うことができる強力なツールです。

構造体の変数間でSwapを行う場合、それぞれのメンバーを個別に交換する必要があります。

以下に示すサンプルコードは、2つの構造体型変数の値を交換する例です。

構造体Personは、「name」と「age」の2つのメンバーを持ちます。

Swap関数では、それぞれのメンバーを別々にSwapしています。

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

typedef struct {
    char name[100];
    int age;
} Person;

void swapPerson(Person *x, Person *y) {
    Person temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    Person person1 = {"Alice", 20};
    Person person2 = {"Bob", 30};

    printf("Before swap:\n");
    printf("Person1: %s, %d\n", person1.name, person1.age);
    printf("Person2: %s, %d\n", person2.name, person2.age);

    swapPerson(&person1, &person2);

    printf("After swap:\n");
    printf("Person1: %s, %d\n", person1.name, person1.age);
    printf("Person2: %s, %d\n", person2.name, person2.age);

    return 0;
}

このコードでは、まずPersonという構造体を定義し、その後でSwap関数を使って2つのPerson型の変数を交換しています。

この例では、交換前と交換後のPerson1とPerson2の名前と年齢を表示してSwapが正しく行われたことを確認しています。

これを実行すると、次の出力結果が得られます。

Before swap:
Person1: Alice, 20
Person2: Bob, 30
After swap:
Person1: Bob, 30
Person2: Alice, 20

このように、Swap関数を使って構造体の中身を簡単に交換することができます。

ただし、構造体のサイズが大きくなると、Swap関数のコストも高くなります。

そのような場合には、構造体のポインタを交換するといった方法が考えられます。

次に進む前に、このコードのポイントをいくつか解説します。

まず、Swap関数では、引数としてポインタを取っています。

これは、関数の引数は値渡しであるため、関数内で引数の値を変更しても、それが呼び出し元に影響を与えないからです。

そのため、関数内で変数の値を変更し、それを呼び出し元に反映させるためには、ポインタを使って変数のアドレスを渡す必要があります。

次に、typedef struct {...} Person;という記述について解説します。

これは、新しい型Personを定義するためのものです。

この記述により、Personという型を作り、それを使って変数を宣言することができます。

このように、C言語では自分で新しい型を作ることが可能です。

○サンプルコード4:ポインタを使ったSwap

このセクションでは、C言語の基本的な要素であるポインタを使用して、変数の値を交換する方法を紹介します。

ポインタは変数のメモリ上のアドレスを指すもので、その力を活用すれば、Swap関数をより効率的に作ることができます。

#include<stdio.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5;
    int y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

上記のコードでは、swap関数に二つの変数xyのアドレスを送信します。

その後、そのアドレスにある変数の値を直接変更します。

これにより、関数内で行われた変更が関数の外でも維持されます。

このコードを実行すると、次の出力が得られます。

Before swap: x = 5, y = 10
After swap: x = 10, y = 5

この結果からわかるように、xyの値が交換されています。ポインタを使うことで、関数内での変数の変更がそのまま関数の外でも反映され、元の変数の値を変えることが可能になります。

しかし、ポインタを使用する際は注意が必要です。

ポインタは直接メモリを操作するため、誤った使用は思わぬエラーや問題を引き起こす可能性があります。

特に、無効なメモリアドレスを参照すると、プログラムがクラッシュする原因となります。

そのため、ポインタを使用する際はその挙動をよく理解し、慎重にコードを書くことが重要です。

○サンプルコード5:関数ポインタを使ったSwap

C言語では、関数も変数として扱うことができます。

これにより、関数を引数として他の関数に渡したり、関数の戻り値として利用したりすることが可能になります。

この概念を利用して、Swap関数をさらに汎用的に作ることができます。

#include<stdio.h>

void swap(int* a, int* b, void (*func)(int*, int*)) {
    func(a, b);
}

void swap_logic(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5;
    int y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    swap(&x, &y, swap_logic);
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

このコードでは、Swap関数のロジックを別の関数swap_logicとして定義し、その関数ポインタをswap関数に渡します。

すると、swap関数はこの関数ポインタを使って、実際のSwapロジックを実行します。

このコードを実行すると、次の出力が得られます。

Before swap: x = 5, y = 10
After swap: x = 10, y = 5

この結果からわかるように、xyの値が交換されています。

関数ポインタを使うことで、関数のロジックを外部から注入し、関数の振る舞いを柔軟に変更することが可能になります。

しかし、関数ポインタを使用する際も注意が必要です。

関数ポインタは間違った使用をすると複雑なバグを引き起こす可能性があります。

特に、間違った型の関数を指定したり、存在しない関数を指定したりすると、プログラムが正しく動作しない可能性があります。

そのため、関数ポインタを使用する際はその挙動をよく理解し、慎重にコードを書くことが重要です。

○サンプルコード5:関数ポインタを使ったSwap

関数ポインタとは何かというと、関数のアドレス(つまり、その関数が存在するメモリの場所)を保存し、その情報を利用して関数を呼び出すためのポインタの一種です。

関数ポインタを使ったSwapの実行例を紹介します。

#include<stdio.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void execute_swap(void (*func)(int*, int*), int* a, int* b) {
    func(a, b);
}

int main() {
    int x = 5;
    int y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    execute_swap(swap, &x, &y);
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

このコードでは、関数ポインタを使ってSwapを実行しています。

この例ではまず、swap関数を定義して、次に、関数ポインタを引数に取り、その関数ポインタを通じてSwapを実行するexecute_swap関数を定義しています。

そして、メイン関数内でexecute_swap関数を呼び出して、引数の値を交換しています。

上記のコードを実行すると、次のような出力結果が得られます。

Before swap: x = 5, y = 10
After swap: x = 10, y = 5

これにより、関数ポインタを使って2つの変数の値を交換することが可能であることがわかります。

つまり、このSwap関数の形は関数の引数として関数自体を取り、それを実行する形となります。

これにより、コードの可読性や再利用性を高めることが可能です。

ここで注意が必要なのは、関数ポインタの型が関数のシグネチャ(引数の型と数、返り値の型)と一致していなければならないという点です。

一致していない場合、コンパイラはエラーを出力します。

また、関数ポインタを使ったSwapの応用例としては、関数を引数として他の関数に渡し、その関数内で異なる関数を動的に呼び出すことが可能です。

これにより、プログラムの動作を柔軟に変更することができます。

この機能は、ソフトウェアの設計パターンである「ストラテジーパターン」でよく使用されます。

○サンプルコード6:マクロを使ったSwap

次に、マクロを使ったSwapのサンプルコードを見てみましょう。

マクロは、コードの一部を置き換えるための強力なツールですが、同時に予期しない副作用を引き起こす可能性もあります。

そのため、使用には注意が必要です。

マクロを使って変数を交換するコードを紹介します。

#include<stdio.h>

#define SWAP(a, b) do { a ^= b; b ^= a; a ^= b; } while(0)

int main() {
    int x = 5;
    int y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    SWAP(x, y);
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

このコードでは、XOR(排他的論理和)を使用して2つの整数の値を交換しています。

この例では、SWAPというマクロを定義し、それを使って変数xとyの値を交換しています。

XORを用いることで、一時的な変数を作成することなく値の交換が可能です。

上記のコードを実行すると、次のような出力結果が得られます。

Before swap: x = 5, y = 10
After swap: x = 10, y = 5

これにより、マクロを用いたSwapに成功していることが確認できます。

この形のSwap関数は非常に一般的で、多くのプログラムで見かけることができます。

ただし、マクロはプリプロセッサによって処理されるため、デバッグが難しくなる可能性があります。

また、マクロは型を持たないため、型のチェックが行われません。

そのため、型が一致しない変数をSwapしようとすると、予期せぬ動作が起こる可能性があります。

したがって、マクロを使ったSwapは使用時には注意が必要です。

○サンプルコード7:テンプレートを使ったSwap

前述したように、C言語はテンプレートをサポートしていませんが、C++ではテンプレートを使用したSwap関数の作成が可能です。

このサンプルではC++のコードを見てみましょう。

ここではテンプレートを使用することで、どのようなデータ型でも同じSwap関数を利用できるというメリットを体験します。

この例ではテンプレートを使って関数を定義し、2つの値を交換しています。

// C++のテンプレートを使ったSwap関数
template <typename T>
void swap(T* a, T* b) {
    T temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int a = 5;
    int b = 10;
    swap<int>(&a, &b);

    double c = 1.5;
    double d = 2.5;
    swap<double>(&c, &d);

    // a, b, c, dの値を出力する
    std::cout << "a: " << a << ", b: " << b << std::endl;
    std::cout << "c: " << c << ", d: " << d << std::endl;

    return 0;
}

このコードでは、最初にテンプレートを使用したSwap関数を定義しています。

テンプレートは template <typename T> の形で指定され、Swap関数の中ではこの T をデータ型として使用しています。

つまり、T は関数が呼ばれる時に具体的な型に置き換わります。

そして main 関数の中で、2つの異なる型の値(整数と実数)をSwap関数に渡しています。

このコードを実行すると、出力結果は次のようになります。

a: 10, b: 5
c: 2.5, d: 1.5

この結果から、2つの整数値と2つの実数値が正しく交換されていることがわかります。

これは、テンプレートを使用したSwap関数が異なるデータ型の値に対して動作することを表しています。

したがって、テンプレートを使用することで、一つのSwap関数を複数のデータ型に対して再利用することが可能になります。

ただし、このテクニックはC++でしか使えないため、C言語を使用する場合は、データ型ごとにSwap関数を定義する必要があります。

○サンプルコード8:演算子を使ったSwap

それでは次のサンプルコードを見てみましょう。

ここでは、演算子を用いて値のSwapを実現します。

#include<stdio.h>

void swap(int* a, int* b) {
    *a = *a ^ *b;
    *b = *a ^ *b;
    *a = *a ^ *b;
}

int main() {
    int x = 5, y = 10;
    printf("Before Swap: x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("After Swap: x = %d, y = %d\n", x, y);
    return 0;
}

このコードでは、ビット演算子の排他的論理和(XOR)を使って二つの数値を入れ替える方法を表しています。

XORは二つのビットが異なる場合に1を、同じ場合に0を返す性質を利用します。

これにより、追加の変数を使わずにSwapを行うことができます。

具体的には、まずaとbのXORを取り、その結果をaに代入します。

次に、新たに更新されたaとbのXORを取り、その結果をbに代入することで、bには元のaの値が入ります。

最後に、再度aとb(元のaの値が入っている)のXORを取り、その結果をaに代入することで、aには元のbの値が入ります。

これにより、aとbの値をSwapすることができます。

このコードを実行すると、”Before Swap: x = 5, y = 10″と表示された後に、”After Swap: x = 10, y = 5″と表示されます。

これにより、xとyの値がSwapされていることがわかります。

ただし、この方法は一見すると魔法のように見えますが、いくつか注意点があります。

まず、aとbが同じ場所を指す場合(つまり、aとbが同じ変数を指す場合)、この方法を使うとその変数の値が0になってしまいます。

これは、任意の数値xに対して、x XOR xが常に0であるためです。

さらに、この方法は整数に対してのみ有効であり、浮動小数点数や構造体などに対しては適用できません。

また、ビット演算子を使うとコードが読みにくくなるという問題もあります。

この方法の応用例としては、大きな配列の要素をSwapする場合などに利用できます。

大きなデータをSwapする場合、一時的な変数にデータをコピーするのは時間とメモリを消費しますが、この方法ならばその必要がありません。

○サンプルコード9:ユーザ定義関数を使ったSwap

このコードでは、ユーザ定義関数を使って2つの変数の値を交換するコードを紹介しています。

この例では、ユーザ定義関数swapを定義し、その中でtempという一時的な変数を使って値の交換を行っています。

#include<stdio.h>

void swap(int *x, int *y) { 
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}

int main() {
    int a = 10, b = 20;
    printf("交換前:a = %d, b = %d\n", a, b);
    swap(&a, &b);
    printf("交換後:a = %d, b = %d\n", a, b);
    return 0;
}

このコードでは、まずswapという名前のユーザ定義関数を作成しています。

この関数は2つの引数、すなわち2つのポインタを受け取り、その指す場所の値を交換します。

具体的には、swap関数内でtempという一時的な変数を用意し、まず一方の変数の値をtempに保存します。

その後、もう一方の変数の値を先の変数に代入し、最後にtempに保存していた値をもう一方の変数に代入します。

これにより、2つの変数の値が交換されるのです。

次にmain関数内で、aとbという2つの変数を定義し、それぞれに10と20という値を代入します。

そして、値が交換される前のそれぞれの変数の値を出力した後、swap関数を呼び出して2つの変数の値を交換します。

最後に、値が交換された後のそれぞれの変数の値を出力します。

このコードを実行すると、次のような結果が得られます。

交換前:a = 10, b = 20
交換後:a = 20, b = 10

これは、swap関数によりaとbの値が正しく交換されたことを表しています。

このように、ユーザ定義関数を使ったSwapは、具体的な処理を明確にしたい場合や、同じ処理を何度も使い回したい場合などに特に便利です。

しかし、このようなSwap関数を使う際の注意点として、ポインタを引数とする関数は呼び出し元の変数の実体(値そのものではなく、値が格納されているメモリのアドレス)を操作することが可能なので、間違った使い方をすると思わぬバグの原因になり得ます。

そのため、ポインタを理解し、正しい使い方をすることが重要です。

さらに、このSwap関数をカスタマイズするための一例として、Swap対象の変数の型をint型から他の型(例えばdouble型やchar型など)に変えることも可能です。

その場合、関数の引数と一時的な変数の型も適宜変更する必要があります。

これにより、Swap関数の汎用性を高めることが可能です。

○サンプルコード10:クラスを使ったSwap

最後に、C言語ではなくC++を使用した場合のSwap関数の使い方を紹介します。

具体的には、クラスとそのメンバ関数を使用してSwapを実行する方法です。

クラスは、複数の変数とそれらを操作する関数をまとめたもので、オブジェクト指向プログラミングの基本的な要素です。

// C++のクラスを使用したSwap関数
#include<iostream>
using namespace std;

class SwapClass {
public:
    void swap(int &a, int &b) {
        int temp = a;
        a = b;
        b = temp;
    }
};

int main() {
    SwapClass sc;
    int x = 5, y = 10;
    cout << "Before Swap: x = " << x << ", y = " << y << endl;
    sc.swap(x, y);
    cout << "After Swap: x = " << x << ", y = " << y << endl;
    return 0;
}

このコードでは、SwapClassという名前のクラスを定義し、その中にswapというメンバ関数を作りました。

swapメンバ関数は、引数として参照渡しを受け取り、中で値を交換します。

main関数内では、SwapClassのオブジェクトscを生成し、そのswapメンバ関数を使って変数xとyの値を交換します。

実行結果は「Before Swap: x = 5, y = 10」から始まり、「After Swap: x = 10, y = 5」で終わり、期待通りの動作が確認できます。

●Swap関数の注意点と対処法

これまでに説明してきたように、Swap関数は非常に便利なツールですが、使用する際には注意点がいくつかあります。

①関数の引数は値渡し

C言語では関数の引数は基本的に値渡しとなります。

これは関数に値を渡したとき、その値が関数内部でコピーされるということを意味します。

したがって、関数内で引数の値を変更しても、関数の外側の値は変更されません。

この性質はSwap関数の動作に影響を及ぼすため、Swap関数を使う際には引数を参照渡し(またはポインタ渡し)する必要があります。

②ポインタの使用

Swap関数では通常、引数を参照渡し(またはポインタ渡し)します。

しかし、ポインタを扱う際には注意が必要です。

特に、ポインタが指し示すメモリ領域にアクセスする前に、そのポインタが有効な(つまりNULLでない)メモリを指していることを確認することが重要です。

以上の2つの注意点を理解し、適切に対処することで、Swap関数を安全かつ効果的に利用することができます。

●Swap関数のカスタマイズ方法

基本的なSwap関数は2つの変数の値を交換する非常に単純なものですが、これを応用したりカスタマイズしたりすることで、様々な場面での使用が可能となります。

例えば、配列内の要素を入れ替えるためのSwap関数を作成することができます。

この場合、関数の引数は配列と交換する2つのインデックスとなります。

void swap_in_array(int array[], int index1, int index2) {
    int temp = array[index1];
    array[index1] = array[index2];
    array[index2] = temp;
}

このコードでは、swap_in_arrayという関数を使って配列内の要素を入れ替えています。

引数は、操作対象の配列と入れ替えたい2つのインデックスです。

まとめ

以上、C言語のSwap関数についての詳細なガイドを提供しました。

基本的な使い方から、配列の要素、構造体、クラスを使ったSwapまで、様々なサンプルコードを通じて理解を深めることができたことでしょう。

Swap関数は、プログラミングの基礎を理解し、アルゴリズムを学ぶ上で非常に重要なツールです。

本記事が、その理解と使用に役立つことを願っています。

最後までお読みいただき、ありがとうございました。