《問題》
任意の型value1およびvalue2を入れ替える関数swap()を作成しなさい。

《解答例》
数値型でも文字列でも構造体でも入れ替えることができることができるようにするには、どうすればいいのか。
文字列を扱うことから、ポインタのポインタが必要なことはわかる。では、swap()に渡される値がどのような型になるのかは、想定できない。でも、C言語にはvoid*と言うのがある。
これは、どのような型かはわからないけれど、とりあえずなにかのポインタであると言うことがわかる型である。
実際に書くとこうなる。

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

int     swap(void **value1, void **value2)
{
        void *work = NULL;

        work = *value1;
        *value1 = *value2;
        *value2 = work;

        return(0);
}

まるで、文字列のときと同じように見える。と言うかchar**がvoid**に替わっただけ。これで、どのような方が来ても対応できるはず。
ただし、呼び出す側にはちょっと工夫が必要になってくる。

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

typedef struct person {
        int     id;
        char    name[50];
} PERSON;

int     main(int argc, char *argv[])
{
        int     a = 100;
        int     b = 200;
        int     *pa = &a;
        int     *pb = &b;
        char    x[] = "abc";
        char    y[] = "xyz";
        char    *px = x;
        char    *py = y;
        PERSON  emp1;
        PERSON  emp2;
        PERSON  *pe1 = &emp1;
        PERSON  *pe2 = &emp2;

        swap((void **)&pa, (void **)&pb);
        swap((void **)&px, (void **)&py);
        swap((void **)&pe1, (void **)&pe2);

        exit (0);
}

swap()を呼び出す場合、引数がポインタのポインタになっているので、それにあわせる必要があるのと、void**なのでキャストをする必要がある。

《問題》
以下の構造体PERSON型変数value1およびvalue2を入れ替える関数stswap()を作成しなさい。

typedef struct person {
        int     id;
        char    name[50];
} PERSON;

《解答例》
今回はオリジナルの構造体。さて、この場合数値または文字列のどちらにすればいいのか?
とりあえず、数値型と同じように作ってみる。

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

int     stswap(PERSON *value1, PERSON *value2)
{
        PERSON  work;

        work = *value1;
        *value1 = *value2;
        *value2 = work;

        return(0);
}

実はこれであっさりと動いてしまう。
なぜなら、構造体といえどもひとつの「型」として取扱えるので、数値型と同じように取扱うことができる。逆に言うと、文字列のときが特殊と言うかC言語には「文字列」という型がなく、そのため「文字型の配列」で代用しているため、このようなことが起こる。早い話、C言語に「文字列型」あればよかったと言うことかな。
でも、そんなことをいっても仕方がないので、文字列をきちんと取扱えるようになる必要がある。

《問題》
文字列型変数value1およびvalue2の中身を入れ替える関数sswap()を作成しなさい。ただし、strcpy()、memcpy()などは使用しないこと。

《解答例》
数値型のnswap()の応用版。ただし、文字列のコピーなどを使用しないで作成する。
とりあえず、ポインタを使って書いてみる。

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

int     sswap(char *value1, char *value2)
{
        char *work = NULL;

        work = value1;
        value1 = value2;
        value2 = work;

        return(0);
}

残念ながら、これだとsswap()から戻ると値が戻っていることに気づくはず。
なぜなら、C言語では文字列自体がポインタで表現されているため、*value1、*value2で受け取った値は文字列そのものを受け取ったことになる。すなわち、nswap()でのvalue1、value2と同じ状態になっている。
では、文字列を入れ替えるにはどうすればいいか…ポインタのポインタを使用する。

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

int     sswap(char **value1, char **value2)
{
        char *work = NULL;

        work = *value1;
        *value1 = *value2;
        *value2 = work;

        return(0);
}

こうすることにより、*value1、*value2で文字列が格納されているポインタ(アドレス)にアクセスできるため、ポインタを入れ替えることにより、呼び出し元の変数が指している文字列のポインタを変更することができる。なお、sswap()内では、文字列自体には一切手を付けていない。
まぁ、こんなことをしなくてもstrcpy()を使えば一発なんだけれど、それを言ってしまえば実もふたもなくなるということで…。

《問題》
数値型の変数value1およびvalue2の中身を入れ替える関数nswap()を作成しなさい。

《解答例》
C言語を学ぶ上でのバイブルともいえる「プログラミング言語C」にも書いてある有名な例題。

普通に書くとたぶんこんな感じになるのかな。

#include   <stdio.h>
#include   <stdlib.h>
#include   <string.h>
int     nswap(int value1, int value2)
{
        int     work;

        work = value1;
        value1 = value2;
        value2 = work;

        return(0);
}

ただ、こうするとnswap()の中では確かにvalue1とvalue2の内容は入れ替わるがnswap()から戻ったら元の状態になっている。
C言語では、関数の引数は値渡しとなっているため、nswap()が扱うvalue1、value2はそれぞれコピーされたものになる。よって、nswap()内でいくら値を変更しても呼び出した側へ影響を与えることはない。
では、nswap()で引数の内容を変更して戻すにはどうすればいいか…そう、ポインタを使う。

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

int     nswap(int *value1, int *value2)
{
        int     work;

        work = *value1;
        *value1 = *value2;
        *value2 = work;

        return(0);
}

value1およびvalue2をポインタで受けることにより、*value1、*value2で直接呼び出し元の変数にアクセスすることができるようになる。

関数ポインタって、引数として変数ではなく関数を渡すもの。百聞は一見にしかずということで、前回使ったキュー&スタックに検索用の関数を追加する。

《que.h(追加分)》

int    que_search(
        const void *target, void **data,
        int (*search)(const void *src, const void *dst)
);

プロトタイプ宣言にque_search()を追加する。関数ポインタとしてsearch()を受取る。search()には、比較元のデータであるsrcと比較対象のデータであるdstが必要。

《que.c(追加分)》

int     que_search(const void *target, void **data, int (*search)(const void *src, const void *dst))
{
        QUE     *p = NULL;
        int     status;

        p = root.next;

        for(;;) {
                if (p == &root) {
                        return(1);
                }
                status = search(target, p->data);
                if (status == 0) {
                        *data = p->data;
                        free(p);
                        return(0);
                } else {
                        p = p->next;
                }
        }

        return (0);
}

変数targetと、QUEの中に格納されているdataの値を関数ポインタのsearch()に渡して、その結果が0である場合に、一致したとしてQUEの中にあるdataを返す。
ここで、重要なのがsearch()には、上にも書いた二つの引数以外に、戻り値としてsrcとdstが一致した場合には0、不一致の場合には0以外を返す必要がある。

《main.c》

#include  "que.h"

int     main(int argc, char **argv)
{
        int     status;
        char    *str = NULL;
        char    *src = NULL;

        status = que_enque("fuga");
        status = que_enque("hoge");
        status = que_enque("geho");
        status = que_enque("one");
        status = que_enque("two");
        status = que_enque("three");

        src = strdup("fuga");
        status = que_search (src, (void **)&str, datacmp);
        if (status) {
                fprintf(stderr, "%s is not found.\n", src);
        } else {
                puts(str);
        }
        exit(0);
}

int     datacmp(const void *src, const void *dst)
{
        int     status;

        status = strcmp(src, dst);

        return (status);
}

データ比較用関数として、datacmp()を作成。見たとおり内部でstrcmp()を呼んでいるだけなので、特に関数を作る必要はない。ただ、これを応用することによって、文字列以外のデータについても検索することができるようになる。

会社でのC言語研修の問題として、定番だけどキュー&スタックを考えた。
キューとスタックはよく似ていて、違うのはデータの取出す順序が先に入れたものから取出す(キュー)のか、後から入れたものから取出す(スタック)ぐらい。
そこで、キューとスタックをまとめてあつかえるプログラムを作ってみた。きちんとエラー処理はしていないので、もし使うのであれば、その辺はきちんと作る必要がある。

《que.h》

#ifndef _QUE_H_
#define _QUE_H_

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

#define         GET_QUE         1
#define         GET_STACK       0

/* structuers   */
typedef struct que {
struct  que     *prev;
struct  que     *next;
        void    *data;
} QUE;

/* function prototype   */
int     que_init();
int     que_enque(void *data);
int     que_deque_first(void **data);
int     que_deque_last(void **data);

#endif  /* _QUE_H_      */

《que.c》

#include        "que.h"

static  QUE     root;

static  int     que_deque(void **data, int get_type);

int     que_init()
{
        memset (&root, 0, sizeof(root));
        root.prev = &root;
        root.next = &root;

        return(0);
}

int     que_enque(void *data)
{
        QUE     *p      = NULL;
        QUE     *last   = NULL;

        p = (QUE *) malloc (sizeof(QUE));

        if (root.next == &root || root.prev == &root) {
                root.next = p;
                root.prev = p;
                p->prev = &root;
        } else {
                last = root.prev;
                last->next = p;
                root.prev = p;
                p->prev = last;
        }

        p->next = &root;
        p->data = data;

        return(0);
}

int     que_deque_first(void **data)
{
        int     status;

        if (root.next == &root) {
                return(1);
        }

        status = que_deque(data, GET_QUE);

        return(status);
}

int     que_deque_last(void **data)
{
        int     status;

        if (root.prev == &root) {
                return(1);
        }

        status = que_deque(data, GET_STACK);

        return(status);
}

static  int     que_deque(void **data, int get_type)
{
        QUE     *p      = NULL;

        if (get_type) {
                p = root.next;
                p->next->prev = p->prev;
                root.next = p->next;
        } else {
                p = root.prev;
                p->prev->next = p->next;
                root.prev = p->prev;
        }

        *data = p->data;
        free(p);

        return(0);
}

que_deque()内で、キューまたはスタックの切替えを行っている。使用する場合は、ラッパーであるque_deque_first()、que_deque_last()でキューまたはスタックを選択する。