構造体

目次

• アルゴリズムとデータ構造
• 構造体とは
• 構造体の定義と，変数の定義


• 構造体の配列
• 構造体へのポインタ

アルゴリズムとデータ構造

コンピュータでのさまざまな情報処理を考える場合，その設計に必要なものは「アルゴリズム」と「データ構造」である．

• 「アルゴリズム」は計算手順そのものであり，今まで習った「条件分岐」「繰り返し」「関数」などを組み合わせ，どのような方法で計算を進めるか（例えばソーティング等）をあらわしたものである．
• 「データ構造」は，そもそも処理したい情報を計算機上でどのように表現するのかを規定するものであり，単純な整数型，実数型のみならず，配列や今回学ぶ構造体などを組み合わせて用いる．データの表現方法そのものを表す．

今回は「データ構造」の表現手法として重要な構造体について詳しく学ぶ．
構造体（structure）とは，C言語に限らず 既存のデータ型を組み合わせ，新しいデータ型をユーザが定義する機能である．
データや値（＝何らかの情報）は，お互いに関連がある場合が多く，この様なデータをまとめて管理できると都合が良い．
例：住所録（名前，住所，電話番号など），複素数（実部，虚部），3次元座標（x, y, z），ベクトル(u, v, w)，行列・テンソル（mxn），音声ファイル（サンプリング周波数，ステレオかモノラルか，左チャンネル・右チャンネル），画像ファイル（幅，高さ，色数，圧縮形式，画像本体）など

構造体とは

互いに関連のある複数の数値，文字，配列などを組みあわせて，概念的に新しい型を作り出す手法を「構造体」(structure)と呼ぶ．

構造体にはいろいろな変数を含むが，それらを構造体の メンバ変数，または，単に「メンバ」と呼ぶ．
データ構造の一種である配列は，全ての要素が同じ型の集合であるのに対し，構造体はそれぞれのメンバが異なる型を持つことができる． （同じ型でも良い．）

複数のメンバ変数を有する構造体の定義は，struct キーワードを用いて次の通りに記述する．

struct 構造体名
{
    型名 変数名1;
    型名 変数名2;
    型名 変数名3;
    ・・・
    型名 変数名N;
};                   // ここにセミコロン必要

例えば，複素数（実部と虚部で構成される）を表す構造体 Complexの定義は，以下のような書き方となる．

struct Complex
{
    double re;      // 実部  real part
    double im;      // 虚部  imaginary part
};

// 文法上，関数の定義によく似ているが，() がつかないのと，最後の ; が異なる．

このように書くと，

• 構造体の名称は「Complex」
• メンバ変数は，double型の re と im の2つ

である，という意味となる．

構造体のメンバ変数には，組込型（int, floatなどのプリミティブ型）だけでなく，その配列や文字列，ポインタ変数，さらには別の（定義済みの）構造体が含まれても良い．
したがって，構造体にどのような型の変数を，何個含めるか，即ち，どのような情報を概念的にまとめて扱うかを定義する事は， まさにそのプログラムの処理すべき情報表現の設計そのものである．

次に，このように定義した構造体を用いて，新しく変数を定義するときは，構造体名と変数名を順に記述する．
これは組み込み型の変数定義と同様である． つまり，構造体名＝型名のような役割を果たすと考えればわかりやすい、

Complex z;       // 構造体（ここではComplex型）の変数定義
int i;           // 組み込み型変数の定義
char str[100];   // 配列の定義

メンバ変数へのアクセス

構造体内のメンバ変数に値を代入したり，逆に値を取り出して別の変数に代入するには，以下のドット演算子（ . ）を用いる．

（構造体型の）変数名.メンバ変数名

ドット演算子を含め，「構造体変数名.メンバ変数名」で，一つの変数と見ればわかりやすい．

#include <stdio.h>

struct Complex     // 複素数クラス
{
    double re;    // 実部
    double im;    // 虚部
};

int main(void)
{
    Complex z;           // 構造体型の変数定義

    z.re = 1.0;    // メンバ変数に代入
    z.im = 2.0;    // メンバ変数に代入

    printf("z = (%lf , %lf)\n", z.re , z.im );    // メンバ変数の参照

    return 0;
}

構造体変数は通常の変数と同様，関数の引数とすることができ，構造体変数を一つ渡せば，メンバ変数がすべて（値渡しで）渡されるので非常に便利である．
戻り値についても同様であり，複数の値を return 文で返したい場合は，構造体を使うという方法もある．

#include <stdio.h>
#include <math.h>     // sqrt関数用

struct Complex     // 複素数クラス
{
    double re;    // 実部
    double im;    // 虚部
};


double zabs(Complex c)      // 複素数の絶対値を返す関数．引数は構造体である Complex 型
{
    return sqrt( c.re * c.re + c.im * c.im);
}

int main(void)
{
    Complex z;           // 構造体変数の定義

    // 基本的には，メンバ変数にそれぞれ代入する．
    z.re = 1.0;
    z.im = 2.0;
    
//    z = {10.0, 20.0};		// このような代入が可能なコンパイラもある．

    printf("z = (%lf , %lf)\n", z.re , z.im );
    printf("abs(z) = %lf\n", zabs(z) );         // 関数の呼び出し

    return 0;
}

いろいろな構造体の例

よくある構造体の例をいくつか示す．
ここに示したのは一例であり，変数名や構造体名などは任意につけることができる．

例：2次元空間座標（直交座標）
struct Coord          // coordinate：座標
{
    double x;  // x 座標
    double y;  // y 座標
};


このようにまとめて書いてもよい．
struct Coord
{
    double x, y;  // x,y 座標
};


例：2次元空間座標（極座標表現）
struct Coord_polar
{
    double r;      // r
    double theta;  // theta
};


構造体内に配列があってもOK．
struct Coord
{
    double x[2];  // x[0], x[1]は x座標, y座標，または r, theta
};

3次元座標の場合
struct Coord
{
    double x, y, z;  // x,y 座標
};

または
struct Coord
{
    double x[3];  // x[0]が x 座標, x[1]が y 座標, x[2]が z 座標
};

例：2次元ベクトル
struct Vector2D
{
    double x0, y0;  // 始点
    double x1, y1;  // 終点
};


構造体内に定義済の別の構造体を用いてもOK．
struct Vector2D
{
    Coord beg;  // 始点
    Coord end;  // 終点
};

画像ファイル
struct BitmapImage
{
    unsigned int width;  // 画像の幅
    unsigned int height; // 画像の高さ
    int type;            // 画像の種類，モノクロ or カラー
    int* img;            // 画像本体を指すポインタ
};

ゲームキャラクターのステータス
struct BitmapImage
{
    int Lv;   // レベル
    int HP;   // ヒットポイント
    int MP;   // マジックポイント
    int Exp;  // 経験値
    int Pw;   // 攻撃力
    int De;   // 守備力
};

構造体の定義と，変数の定義

データ表現を決める「構造体の定義」と，その変数を実際にメモリ上に確保する「構造体変数の定義」は同時に行うこともできるが，通常は別々に行う．

例えば，以下のような構造体の定義はソースファイルの先頭付近，または別途ヘッダファイル(.h)を作成し，それを #include して使う．

// 構造体の定義，即ちデータ構造の定義である．
// 使用するソースコードの上方に記述するか，ヘッダファイル (.h) として別ファイルを作る．

//  例：住所録
struct AddressRecord
{
    char name[40];         // 氏名

    int postal_code1;    // 郵便番号，最初の3桁
    int postal_code2;    // 郵便番号，最後の4桁

    char address[80];      // 住所
    char phone_number[20]; // 電話番号
};

一方，構造体型の変数の定義は，実際に使用する場所（通常は.cppファイル）の中で行われる．
通常の変数と同様，構造体変数の配列や，構造体を指すポインタも定義できる．

// 構造体変数の定義．
// これよりも前方に構造体の定義が必要！

AddressRecord card;             // 構造体 AddressRecord 型の変数 card を定義．
AddressRecord cards[100];       // 構造体 AddressRecord 型の変数 card を100個分定義．
AddressRecord *p=&cards[0];     // 構造体を指すポインタ

プログラム中では，変数の定義をして初めてメモリ上に領域が確保されることを思い出そう．
構造体の定義だけでは，メモリ上には何も配置されない．あくまでデータ構造を定義したに過ぎない．

struct AddressRecord
{
    ... // 構造体の定義
};

int main(void)
{
    // 変数の定義時に毎回 struct と書く必要あり
    struct AddressRecord card;
    struct AddressRecord card2;
    ...
}

構造体変数の参照・代入

では構造体変数のメンバ変数に，実際に値を代入してみよう．
代入や参照については一般の変数と何ら変わりはない．

注：以下のプログラムでは，名前や住所などの文字列変数に全角文字を使用すると文字化けすることがあるので，ローマ字で記している．

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

struct AddressRecord
{ 
    char name[40];
    int postal_code1;
    int postal_code2;
    char address[80];
    char phone_number[20];
};

int main(void)
{
    // 構造体変数の定義
    AddressRecord card;

    //  メンバ変数にそれぞれ代入
    card.postal_code1 = 214;      // card.postal_code1 で，1つの int 型変数とみなせばよい．
    card.postal_code2 = 8571;

    //  文字列は直接代入できない． strcpy() を使用するべし．

    // card.name = "Rikou Taro"                   //  NG.
    strcpy(card.name,  "Rikou Taro");                   // OK.　card.name は，配列名＝先頭アドレス

    strcpy(card.address,  "Higashimita 1-1-1 Tama-ku Kawasaki"); // 上と同じ
    strcpy(card.phone_number,  "044-934-xxxx");       // 上と同じ

    //  構造体の各メンバ変数の中身を，画面に表示
    printf("%d - %d\n", card.postal_code1, card.postal_code2 );
    printf("%s\n", card.name);
    printf("%s\n", card.address);
    printf("%s\n", card.phone_number);

    return 0;
}

構造体変数の初期化

構造体変数についても「定義と同時に初期化」が可能である．
（配列の場合と同様，構造体変数の「定義と同時に」「定数を」設定することが可能）
構造体変数の初期化は，以下のように変数の定義と同時に，メンバ変数の記述順に，初期化したい定数をカンマ区切りで列挙する．

さらに，配列とは異なり， = 演算子による構造体変数の代入が可能である．

以下は，構造体の定義で示した AddressRecord 構造体を用いた例である．

#include <stdio.h>

// 構造体の定義
struct AddressRecord
{ 
    char name[40];
    int postal_code1;
    int postal_code2;
    char address[80];
    char phone_number[20];
};

int main(void)
{
    // 構造体変数の定義と同時に初期化．
    // メンバ変数の定義順に，変数をカンマ区切りで並べて書く． 
    AddressRecord ar = {"Meiji Jiro", 101, 8301, "Kandasurugadai 1-1 Chiyoda-ku", "03-3296-xxxx"};

    // 以下はOK．同じ種類の構造体変数同士の代入． 
    AddressRecord ar2;
    ar2 = ar;

    return 0;
}

class クラス名
{
private:    // アクセス指定子

    //  メンバ変数
    型名 変数名;

public:    // アクセス指定子
    //  メンバ関数
    戻り値型 関数名(引数, ...);
};

構造体の配列

先の例では，一人分のアドレスを格納できる構造体 struct AddressRecord を定義した．
通常アドレス帳には何人ものデータを記録したいので，このような場合には，構造体を使って配列変数を定義する．
例えば，100人分の連絡先を記録するには，普通の配列と同じく

const int N = 100;
AddressRecord cards[N];      // 構造体の配列

と定義すればよい．
変数 cards は配列なので，それぞれの要素にアクセスするには，

for(int i=0; i<N; i++) {

    cards[i].postal_code1 = 101;
    cards[i].postal_code2 = 8301;

    strcpy(cards[i].name, "Meiji Jiro");
    strcpy(cards[i].address, "Kandasurugadai 1-1, Chiyoda-ku");
    strcpy(cards[i].phone_number, "03-3296-xxxx");
	...
}

とすれば良い．（この例だとfor分で 100件分のレコードにすべて同じデータが入る）
配列アクセスのための [ ] 演算子と，構造体のメンバアクセスのための . 演算子の順番に気をつけよう．

上記の例で，プログラム中での表記と，その意味（＝型）をまとめると，

cards           構造体配列 card の先頭のアドレス
cards[0]        構造体配列 card の先頭の要素（＝AddressRecord型の1個の変数）

cards[0].postal_code1    構造体配列 card の先頭の要素 card[0] のメンバ変数 postal_code1 の値（int型）
cards[0].name            構造体配列 card の先頭の要素 card[0] のメンバ変数である文字列 name の先頭アドレス
cards[0].name[0]         構造体配列 card の先頭の要素 card[0] のメンバ変数である文字列 name の先頭の 1 文字(1文字，char型)

構造体配列の初期化

構造体変数の配列を初期化することも可能である．
二次元配列の初期化とよく似ている．

#include <stdio.h>

// 構造体の定義
struct AddressRecord
{ 
    char name[40];
    int postal_code1;
    int postal_code2;
    char address[80];
    char phone_number[20];
};

int main(void)
{
    const int N = 3;

    // メンバ変数の定義順に，定数を記述．
    AddressRecord cards[N]={{"Meiji Taro",   101, 8301, "Kandasurugadai 1-1, Chiyoda-ku", "03-3296-xxxx"},
                            {"Meiji Jiro",   102, 8302, "Kandasurugadai 2-2, Chiyoda-ku", "03-3297-xxxx"},
                            {"Meiji Saburo", 103, 8303, "Kandasurugadai 3-3, Chiyoda-ku", "03-3298-xxxx"} };

    return 0;
}

構造体へのポインタ

配列へのアクセスでは，ポインタを用いて行われる場合がある．
構造体へのポインタの定義は，その他の変数のポインタの定義と何ら変わらない．

// 普通の構造体変数を指す場合
AddressRecord card;            // 構造体
AddressRecord *p = &card;      // 構造体を指すポインタの定義(と初期化)

// 構造体の配列を指す場合
AddressRecord card_all[100];           // 構造体の配列
AddressRecord *p2 = &card_all[0];      // 構造体を指すポインタの定義．p2 = card_all と等価．

構造体を指すポインタでは，ポインタの指す値へのアクセス方法が，2種類ある．
1つは，通常のポインタ演算子 * である．構造体のメンバにアクセスするには，続けてドット演算子を用いる．

もう1つは，アロー演算子(->)であり，構造体を指すポインタ専用の記号である．

(*p).postal_code1 = 111;       // 通常のポインタ演算子
p->postal_code1   = 102;       // アロー演算子．構造体専用

(*(p2+10)).postal_code1 = 111;
(p2+10)->postal_code1   = 102;

どちらを使っても結果は同じであるので，わかりやすいほうを使用すればよい．

#include <stdio.h>

// 構造体の定義
struct AddressRecord {
    ????;
};

int main(void)
{
    AddressRecord card_all[100];           // 構造体の配列
    AddressRecord *p2 = &card_all[0];      // ポインタ

    printf("%p %p\n", p2, p2+1);
    return 0;
}


    

練習問題