C++編【言語解説】 第13章 コンストラクタとデストラクタ

先頭へ戻る

この章と同じ(または似た)情報を扱うページが、Modern C++編 (C++11/14/17 対応) の以下の章にあります。

この章の概要

この章の概要です。


コンストラクタ

前章までの Studentクラスでは、SetData というメンバ関数を用意して、メンバ変数に初期値を与えるという形を取りましたが、本来は、メンバ変数を初期化するためには、コンストラクタを利用するべきです。

コンストラクタは、オブジェクトがインスタンス化されるときに、自動的に呼び出される特殊なメンバ関数です。「自動的に」というのがポイントで、このおかげで、オブジェクトが未初期化な状態になることを確実に防ぐことができ、安全なプログラムが書けます。

コンストラクタには、クラスと同じ名前を付けます。また、何か結果を返す目的のメンバ関数ではないため、戻り値はなく、戻り値型の指定もしません(「void」を書くこともできません)。

class X {
    X(仮引数の並び);  // コンストラクタの宣言
};

// コンストラクタの定義
X::X(仮引数の並び)
{
}

クラスと構造体は同一の存在なので(第12章)、struct でもコンストラクタは使えます。

クラス定義内でコンストラクタの定義を記述することも可能です。これは、inlineキーワードを指定したことと同じ意味を持ちます(第12章)。

コンストラクタを constメンバ関数にできませんが、const付きのオブジェクトを定義する場合でもコンストラクタは呼び出されるので、特に必要性もありません。

構文の例なので省いていますが、コンストラクタもアクセス指定子の影響を受けます。publicキーワードを使って「公開」しておかないと、クラスの外側でインスタンス化を行うことができなくなります。

インスタンス化を行うときに、コンストラクタが呼び出せない場合は、コンパイルエラーになります。

実際に、コンストラクタを使ってみます。

// student.h

#ifndef STUDENT_H_INCLUDED
#define STUDENT_H_INCLUDED

#include <string>

class Student {
public:
    Student();  // コンストラクタ

    void SetData(std::string name, int grade, int score);
    void Print();

private:
    std::string  mName;   // 名前
    int          mGrade;  // 学年
    int          mScore;  // 得点
};

#endif
// student.cpp

#include "student.h"
#include <iostream>

Student::Student()
{
    mName = "no name";
    mGrade = 0;
    mScore = 0;
}

void Student::SetData(std::string name, int grade, int score)
{
    mName = name;
    mGrade = grade;
    mScore = score;
}

void Student::Print()
{
    std::cout << mName << " "
              << mGrade << " "
              << mScore << std::endl;
}
// main.cpp

#include "student.h"

int main()
{
    Student student;  // インスタンス化される際に、コンストラクタが呼び出される
    student.Print();
    student.SetData("Saitou Takashi", 2, 80);
    student.Print();
}

実行結果:

no_name 0 0
Saitou Takashi 2 80

このサンプルプログラムのように、コンストラクタでは主に、メンバ変数を初期化する作業を行います。ただしできるだけ、次の項で説明する方法を採用してください。

コンストラクタには戻り値がないため、コンストラクタ内で発生したエラーを呼び出し元に伝えるには代わりの手段が必要です。1つの策として、エラーをいったん無視しておいて、あとからメンバ関数経由でエラーの有無を調べられるようにしておく方法があります。この方法は、std::ofstream で、インスタンス化のあとに「if (!ofs)」のようにして問い合わせる形と同じです(第6章)。
もう1つの方法として、例外を使うという手段があります(第32章)。必ずチェックされなければならないエラーを伝えるには、こちらの方が確実です。

メンバイニシャライザ

先ほどのサンプルプログラムのような方法でメンバ変数を初期化しようとすると、結局、代入を使っていることになります。

Student::Student()
{
    // 以下の3つは、すべて代入
    mName = "no name";
    mGrade = 0;
    mScore = 0;
}

これの問題点の1つは、無駄があるということです。メンバ変数自身もコンストラクタを持つことに注意しましょう。つまり、オブジェクトがインスタンス化されるとき、コンストラクタの本体が実行される前に、メンバ変数が作られ、コンストラクタが呼び出されています。

そのため、各メンバ変数はコンストラクタによって初期化された後、さらに代入によって上書きされるという無駄な手順を踏んでしまっています。最初から適切な初期値で初期化された方が無駄がありません。

そこで、メンバイニシャライザという機能を使用します。メンバイニシャライザは、コンストラクタでのみ使える機能で、次のような構文になっています。

// コンストラクタの定義
X::X() : メンバ変数名(初期化子), …
{
}

厳密には、メンバ変数1つ1つの初期化を行っている部分がメンバイニシャライザで、全体としてはメンバイニシャライザリストと呼びます。

コンストラクタの定義の側で記述します。宣言の方には書けません。

コンストラクタの仮引数の並びの後ろに「:」を置き、メンバ変数名と、それに与える初期化子を指定します。メンバ変数が複数あるのなら、「,」で区切って、指定を繰り返します。

コンストラクタの本体のコードが実行される前に、メンバ変数が作られるタイミングで、メンバイニシャライザが機能します。メンバイニシャライザで記述した初期化子は、メンバ変数のコンストラクタの実引数として渡されます。

メンバ変数のコンストラクタが、引数無しで呼び出せるのであれば、メンバイニシャライザに記述しなくても結果は変わりませんが、空の ( ) を指定して、明示的に初期化できます。明示しておいた方が分かりやすいかもしれません。

なお、メンバ変数が const の場合、メンバイニシャライザで初期化しなければなりません。コンストラクタ内で初期化しようとすると、それは代入ですから、const の性質によってコンパイルエラーになってしまいます。

前の項のサンプルプログラムを、メンバイニシャライザを使って書き換えると、次のようになります。

// student.h

#ifndef STUDENT_H_INCLUDED
#define STUDENT_H_INCLUDED

#include <string>

class Student {
public:
    Student();  // コンストラクタ

    void SetData(std::string name, int grade, int score);
    void Print();

private:
    std::string  mName;   // 名前
    int          mGrade;  // 学年
    int          mScore;  // 得点
};

#endif
// student.cpp

#include "student.h"
#include <iostream>

Student::Student() :
    mName("no name"), mGrade(0), mScore(0)
{
}

void Student::SetData(std::string name, int grade, int score)
{
    mName = name;
    mGrade = grade;
    mScore = score;
}

void Student::Print()
{
    std::cout << mName << " "
              << mGrade << " "
              << mScore << std::endl;
}
// main.cpp

#include "student.h"

int main()
{
    Student student;  // インスタンス化される際に、コンストラクタが呼び出される
    student.Print();
    student.SetData("Saitou Takashi", 2, 80);
    student.Print();
}

実行結果:

no_name 0 0
Saitou Takashi 2 80

mName は std::string型であり、その正体はクラス型で、コンストラクタを持っています。メンバイニシャライザに記述した「mName("no name")」は、std::string のコンストラクタに "no name" を渡していることになります。

一方、mGrade や mScore は int型であり、クラス型ではありませんが、「mGrade(0)」や「mScore(0)」という記述で初期化できます。このような初期化の仕方は、普段の変数定義時でも可能です。後で取り上げます

メンバイニシャライザでメンバ変数を記述する順番は、クラス定義の中でメンバ変数を宣言した順番通りにするようにします。メンバ変数のコンストラクタが呼び出される順番は、クラス定義の中でメンバ変数を宣言した順番に合わせられるルールだからです。余計な混乱を招かないように、順番を合わせておきましょう。

デフォルトコンストラクタ

コンストラクタを明示的に定義しなかった場合に限って、コンパイラが自動的にデフォルトコンストラクタを生成します

デフォルトコンストラクタとは、引数無しで呼び出すことができるコンストラクタのことです。デフォルトで生成されるからデフォルトコンストラクタなのではないことに注意してください。

前章までの例では、コンストラクタを定義していませんでしたが、それでもオブジェクトをインスタンス化できていたのは、コンパイラが自動的にデフォルトコンストラクタを生成しているからです。

class Student {
private:
    std::string  mName;   // 名前
    int          mGrade;  // 学年
    int          mScore;  // 得点
};

int main()
{
    Student student;  // デフォルトコンストラクタを呼び出している
}

コンパイラが生成したコンストラクタは、特に何も中身がない空実装のコンストラクタです。つまり、このサンプルプログラムでは、次のようなコンストラクタが自動生成されていると考えられます。

Student::Student()
{
}

メンバ変数を明示的に初期化することもしていませんから、int型の mGrade と mScore は不定値のままです。mName は std::string のデフォルトコンストラクタが呼び出されるので、空文字列で初期化されています。

デフォルトコンストラクタがないと、オブジェクトの配列が作れません。次のサンプルプログラムでは、コンストラクタを明示的に定義しているため、デフォルトコンストラクタが作られません。

class Student {
public:
    Student(std::string name, int grade, int score);

private:
    std::string  mName;   // 名前
    int          mGrade;  // 学年
    int          mScore;  // 得点
};

Student::Student(std::string name, int grade, int score) :
    mName(name), mGrade(grade), mScore(score)
{
}

int main()
{
    Student students[10];  // コンパイルエラー
}

オブジェクトを、動的なメモリ割り当ての手法を使って生成すれば、デフォルトコンストラクタがなくても、配列を使うことは可能です(第14章)。

なお、コンストラクタのすべての仮引数にデフォルト実引数があり、結果的に引数無しで呼び出せるのなら、それもデフォルトコンストラクタとみなせます。

引数付きのコンストラクタ

ここまでのサンプルプログラムでは、コンストラクタの存在意義は、メンバ変数が不定値にならないようにすることでした。結局、適切な値を入れる作業は SetDataメンバ関数に任されており、ある種の2度手間状態は変わっていません。

今度は、オブジェクトがインスタンス化される時点で、適切な値を与えられるようにしてみましょう。そのためには、コンストラクタが引数を持つ必要があります。

コンストラクタに引数を持たせることについては、別段特別に考えるほどのことはありません。コンストラクタ側の宣言や定義は、これといって特別なことはありません。違いはせいぜい、インスタンス化するときに実引数を渡すようになる点ぐらいです。

// 引数付きのコンストラクタを使って、オブジェクトをインスタンス化する
クラス名 変数名(実引数の並び);

実際に試してみましょう。

// student.h

#ifndef STUDENT_H_INCLUDED
#define STUDENT_H_INCLUDED

#include <string>

class Student {
public:
    Student(std::string name, int grade, int score);

    void Print();

private:
    std::string  mName;   // 名前
    int          mGrade;  // 学年
    int          mScore;  // 得点
};

#endif
// student.cpp

#include "student.h"
#include <iostream>

Student::Student(std::string name, int grade, int score) :
    mName(name), mGrade(grade), mScore(score)
{
}

void Student::Print()
{
    std::cout << mName << " "
              << mGrade << " "
              << mScore << std::endl;
}
// main.cpp

#include "student.h"

int main()
{
    Student student("Saitou Takashi", 2, 80);
    student.Print();
}

実行結果:

no_name 0 0
Saitou Takashi 2 80

この形ならば、の無駄がありません。メンバ変数は最初から適切な値で初期化できています。

コンストラクタのオーバーロード

コンストラクタもオーバーロードできます。

// student.h

#ifndef STUDENT_H_INCLUDED
#define STUDENT_H_INCLUDED

#include <string>

class Student {
public:
    Student();
    Student(std::string name, int grade, int score);

    void SetData(std::string name, int grade, int score);
    void Print();

private:
    std::string  mName;   // 名前
    int          mGrade;  // 学年
    int          mScore;  // 得点
};

#endif
// student.cpp

#include "student.h"
#include <iostream>

Student::Student() :
    mName("no name"), mGrade(0), mScore(0)
{
}

Student::Student(std::string name, int grade, int score) :
    mName(name), mGrade(grade), mScore(score)
{
}

void Student::SetData(std::string name, int grade, int score)
{
    mName = name;
    mGrade = grade;
    mScore = score;
}

void Student::Print()
{
    std::cout << mName << " "
              << mGrade << " "
              << mScore << std::endl;
}
// main.cpp

#include "student.h"

int main()
{
    Student student;
    student.Print();

    Student student2("Saitou Takashi", 2, 80);
    student2.Print();
}

実行結果:

no_name 0 0
Saitou Takashi 2 80

オブジェクトをインスタンス化するときに与える実引数に応じて、適切なコンストラクタが呼び分けられます。このルールは、関数オーバーロードのところで解説した通りです(第8章)。

コンストラクタをオーバーロードすると、メンバイニシャライザや、本体のコードがほぼ同じ形になることがあり、共通化を図りたくなります。C++03 の時点ではせいぜい、「非公開」のメンバ関数に括り出すぐらいしかできず、代償として、メンバイニシャライザの使用を諦める必要に迫られることがあります。
C++11 では、コンストラクタから他のコンストラクタを使う、移譲コンストラクタの機能が追加されたため、この問題は解消されています。

C++11 (移譲コンストラクタ)

C++11

(→Modern C++編

C++11 (非staticなメンバ変数の定義箇所での初期化)

C++11

(→Modern C++編

初期化の構文

メンバイニシャライザで「変数名(初期値)」のように、( ) を使って初期化を行いました。この記法はメンバイニシャライザに限らず、変数を宣言して初期化を行うときにも使えます。

変数を宣言して、初期値を与える構文には、以下のものがあります。

int num = 0;
int num = {0};
int num(0);

{ } を使う方法は、配列などを初期化するときに複数の初期化子を指定するために用いますが、単独の変数に対してでも使用できます。単独の変数に対して使う場合、1つ目の書き方とまったく同じ意味です。

{ } を使う初期化は、C++11 以降では解釈が変わっています(Modern C++編【言語解説】第16章)。

3つ目の方法では、型がクラス型の場合は複数の初期化子を、クラス型でない場合は単一の初期化子を指定できます。クラス型の場合は、コンストラクタに対する実引数の指定です。

1つ目と2つ目はコピー初期化、3つ目は直接初期化と呼ばれています。

コピー初期化には「=」が使われていて、直接初期化には使われていないというふうに見えますが、この見分け方は正しくありません。例えば、関数呼び出しの際に実引数を渡して、仮引数を初期化する行為や、戻り値を返すことはコピー初期化です。

コピー初期化には他に、例外(第32章)を送出することや、例外を補足することが含まれています。

直接初期化には、メンバイニシャライザでの初期化や、関数形式キャストや static_cast による初期化があります。

const_cast や reinterpret_cast がないことを疑問に思うかもしれませんが、これらのキャストは新しいオブジェクトを生み出さないので、初期化という概念が登場しないからです。

直接初期化の方には他に、new(第14章)による初期化が含まれています。

コピー初期化と直接初期化の違いは、初期化に先立って、ユーザー定義の型変換の処理(この後で取り上げます)を適用するかどうかです。コピー初期化では適用しますが、直接初期化では適用しません。

この型変換処理が挟まることによって、実行効率を落としている可能性があります。そのため、変数宣言時の初期化には、コピー初期化よりも直接初期化を選ぶ方が良いかもしれません

ところで、以下のように、初期化子を与えずに変数を宣言することがあります。

int num;
int num();     // コンパイルエラー

1つ目の方は、この変数が staticでないローカル変数であれば、未初期化なように見えます。int型のようにクラス型でない型ならばその通りですが、クラス型の場合は、デフォルトコンストラクタが呼び出されます。この初期化方法は、デフォルト初期化と呼ばれています。

2つ目の方法は、コンパイルエラーになります。これは、C++ の文法解析の厄介な問題として有名なのですが、この変数宣言全体の形が、関数を宣言しているように見えてしまうため、エラーになります。つまり、「int」が戻り値型、「num」が関数名、「()」が仮引数のリストに見えるということです。

ただし、メンバイニシャライザのように、文法的に曖昧にならない場面であれば、空の () で初期化することは可能です。この場合、値初期化(第7章)されます。

変換コンストラクタ

実引数を1つだけ指定して呼び出すことができるコンストラクタは、変換コンストラクタと呼ばれます。変換コンストラクタは、そのクラスとは異なる型から、クラスをインスタンス化するものです。

引数が2つ以上あるコンストラクタでも、2つ目以降の引数がデフォルト実引数(第8章)を持つならば、やはり変換コンストラクタと呼びます。

例えば、ファイルを扱う Fileクラスのコンストラクタを、次のように宣言しているとします。

class File {
public:
    File(const char* fileName);
};

const char*型の引数を1つだけ指定して呼び出せますから、これは変換コンストラクタとして機能します。これがあると、コピー初期化の構文であれば、次のようにインスタンス化できます。

File file = "test.bin";  // コピー初期化なら OK
File file("test.bin");   // 直接初期化ではコンパイルエラー

コピー初期化の場合は、ユーザー定義の型変換処理を適用しようするため、変換コンストラクタが機能します。直接初期化では、適用しないためコンパイルエラーになります。

変換コンストラクタだけがユーザー定義の型変換ということではありません。ほかに変換演算子(第19章)があります。

変換コンストラクタがあると、次のような意図しないであろう使い方が可能になってしまいます。

void func(File f);

func("Hello");   // 意図通り?

仮引数が File型の関数に、"Hello" という文字列リテラルを渡そうとしています。恐らく、意図したものではないであろう使い方ですが、const char*型からインスタンス化を行う変換コンストラクタがあるため、コンパイルに成功します。この場面で、変換コンストラクタが機能してしまうのは、引数や戻り値を使って行う初期化はコピー初期化だからです。

このように、変換コンストラクタが定義されていると、暗黙的な型変換が行われ、コードが分かりづらくなることがあります。暗黙的な型変換が行われても分かりづらくならないかどうか、よく検討してください。

暗黙的に型変換されることは望ましくないが、型変換自体は有用であるのなら、暗黙的に機能しないようにできます。そのためには、変換コンストラクタの宣言に、explicit指定子を付加します。

class X {
    explicit X(仮引数の並び);
};

X::X(仮引数の並び)
{
}

explicit の付いた変換コンストラクタは、直接初期化のときにだけ使用され、コピー初期化では使用されません。

class File {
public:
    explicit File(const char* fileName);
};

void func(File f);

int main()
{
    File file = "test.bin";  // コンパイルエラー(コピー初期化)
    File file("test.bin");   // OK(直接初期化)

    // コンパイルエラー(引数の受け渡しはコピー初期化)
    func("Hello");

    // OK(static_cast は直接初期化)
    func(static_cast<File>("Hello"));

    // OK(関数形式キャストは直接初期化)
    func(File("Hello"));
}

実引数を1つ指定するだけで呼び出せるコンストラクタを作る際、それが、変換コンストラクタを作っているというつもりでないのなら(たまたま引数が1個になるというだけならば)、常に explicit を付けるようにした方が良いです。


デストラクタ

確実な初期化を実現する機能がコンストラクタならば、確実な終了処理を実現するのがデストラクタです。デストラクタは、オブジェクトが記憶域期間(C言語編第35章参照)を終えて解体されるときに、自動的に呼び出される特殊なメンバ関数です。

デストラクタには、「~クラス名」という名前を付けます。コンストラクタと同様に、戻り値はないので、戻り値型の指定もしません。また、解体時に自動的に呼び出されるという性質上、情報を渡すこともできないので、引数もありません。

class X {
    ~X();  // デストラクタの宣言
};

// デストラクタの定義
X::~X()
{
}

クラスと構造体は同一の存在なので(第12章)、struct でもデストラクタは使えます。

クラス定義内でデストラクタの定義を記述することも可能です。これは、inlineキーワードを指定したことと同じ意味を持ちます(第12章)。

デストラクタを constメンバ関数にできませんが、const付きのオブジェクトを定義する場合でもデストラクタは呼び出されるので、特に必要性もありません。

構文の例なので省いていますが、デストラクタもアクセス指定子の影響を受けます。publicキーワードを使って「公開」しておかないと、クラスの外側でオブジェクトが解体できなくなります。

オブジェクトが解体できないような使い方をすると、コンパイルエラーになります。

デストラクタを「非公開」にしても、メンバ関数やフレンド(第25章)からは解体できるため、使い方次第ではコンパイルエラーは起きません。

実際に、デストラクタを使ってみます。

#include <iostream>
#include <string>

class MyClass {
public:
    MyClass(std::string s) : mStr(s)
    {
        std::cout << "MyClass(" << mStr << ")" << std::endl;
    }

    ~MyClass()
    {
        std::cout << "~MyClass(" << mStr << ")" << std::endl;
    }

private:
    std::string  mStr;
};


void func()
{
    MyClass c("func");
}  // ここで c の記憶域期間が終わり、デストラクタが呼び出される

int main()
{
    MyClass c("main");
    func();
}  // ここで c の記憶域期間が終わり、デストラクタが呼び出される

実行結果:

MyClass(main)
MyClass(func)
~MyClass(func)
~MyClass(main)

デストラクタでは主に、動的なメモリ割り当てを行ったメンバ変数を解放したり、使用中のファイルを close したりといった、確実に行っておく必要がある後片付けを記述します。std::string が内部で動的に確保した文字列の領域を解放する仕組みもデストラクタです。

なお、プログラマがデストラクタを明示的に定義しなければ、コンパイラが自動生成します。自動生成されたデストラクタの実装は空です。

あまり意味が無さそうに思えますが、デストラクタが呼び出せないと、オブジェクトを破棄できません。例えば、デストラクタがあっても、それが「非公開」であることが理由で呼び出させなければ、そのオブジェクトは破棄できず、コンパイルエラーになります。自動生成されるデストラクタは「公開」されています。

デストラクタの本体の処理が実行された後、メンバ変数それぞれのデストラクタも呼び出されます。メンバ変数のデストラクタを呼び出すときの順番は、コンストラクタが呼ばれた順番の逆です。コンストラクタは、メンバ変数の宣言順に呼び出されるので(前述)、デストラクタはその逆順で呼ばれます。

#include <iostream>
#include <string>

class MyClass {
public:
    MyClass(std::string s) : mStr(s)
    {
        std::cout << "MyClass(" << mStr << ")" << std::endl;
    }

    ~MyClass()
    {
        std::cout << "~MyClass(" << mStr << ")" << std::endl;
    }

private:
    std::string  mStr;
};

class Test {
public:
    Test() : mA("A"), mB("B"), mC("C")
    {
        std::cout << "Test()" << std::endl;
    }

    ~Test()
    {
        std::cout << "~Test()" << std::endl;
    }

private:
    MyClass  mA;
    MyClass  mB;
    MyClass  mC;
};

int main()
{
    Test test;
}

実行結果:

MyClass(A)
MyClass(B)
MyClass(C)
Test()
~Test()
~MyClass(C)
~MyClass(B)
~MyClass(A)

想定通りの順番で呼び出されているようです。するべきではありませんが、もしもメンバイニシャライザの記述順序を変えたとしても、この結果は変わりません。

デストラクタには戻り値がないため、デストラクタ内で発生したエラーを呼び出し元に伝えることができません。そもそも、デストラクタのような終了処理系の関数は、常に成功するように作るべきです。終了処理が成功しないということは、もはや取り返しが付かない状況に陥っていることになるため、プログラムはただちに異常終了された方が良いでしょう。


練習問題

問題① Studentクラスが持つ mName の型を std::string でなく、char*型で管理したいとします。どのように実装しますか?

問題② メンバイニシャライザを使った初期化と、コンストラクタ内で代入によって初期値を設定する方法とで、パフォーマンスにどの程度の違いがあるか、計測してください(パフォーマンス測定マクロが、コードライブラリにあります)。

問題③ int型の変数の値を退避(保存)させておき、最後に確実に元の値を復元することをサポートするようなクラスを設計してください。つまり、次のような挙動になるようにしてください (X がクラスとします)。

int value = 10;

// この関数を呼び出したときに value が 10 なら、
// 抜け出した後も確実に 10 であるようにしたい。
void func()
{
    X store(/* 引数は任意 */);

    value = 50;

    if (/* 何らかの条件式 */) {
        return;
    }

    value = 100;
}


解答ページはこちら

参考リンク



更新履歴

'2018/9/5 全体的に見直し修正。
第19章から、「変換コンストラクタ」を移動してきた。

'2018/7/29 「C++11 (移譲コンストラクタ)」「C++11 (非staticなメンバ変数の定義箇所での初期化)」「C++11 (自動生成されるメンバ関数の明示)」「C++11 (関数定義の削除)」の項の内容を削除。同じ内容を解説している Modern C++編のページへのリンクだけを残した。

'2018/7/13 サイト全体で表記を統一(「静的メンバ」-->「staticメンバ」)

'2018/1/5 コンパイラの対応状況について、対応している場合は明記しない方針にした。

'2017/7/30 clang 3.7 (Xcode 7.3) を、Xcode 8.3.3 に置き換え。

≪さらに古い更新履歴を展開する≫



前の章へ (第12章 アクセス指定子)

次の章へ (第14章 動的なオブジェクトの生成)

C++編のトップページへ

Programming Place Plus のトップページへ


はてなブックマーク Pocket に保存 Twitter でツイート Twitter をフォロー
Facebook でシェア Google+ で共有 LINE で送る rss1.0 取得ボタン RSS
管理者情報 プライバシーポリシー