独習Ｃ＋＋、やさしいＣ＋＋、ウェブサイトと、

いろいろ飛んで勉強しているので、話題が前後したりします。

今回はコンストラクタと静的メンバの仕組みについて。

**コンストラクタ

オブジェクトの作成時に自動的に宣言されるもの。

返り値をもたないのも特徴の１つでしょう。

**静的メンバ

staticですね。グローバル関数扱いできるというやつでした。

ローカル関数と違って、そのクラス自体に紐づけられるので、

値がリセットされたり、オブジェクトによって変わることがない共通のものって感じですかね。

今回のプログラムは、

オブジェクト作成時にコンストラクタが呼び出されて初期化

⇒ setCarで値をセット（ナンバーとガソリン量）

⇒ staticでsumをもつ。オブジェクトができる毎に増えていく

クラス類の説明って車を例にすることが多いですよね。

分かりやすいからかね。

#include <iostream>

using namespace std;

class Car{
private:
    int num;
    double gas;
public:
    static int sum;
    Car();
    void setCar(int n, double g);
    void show();
    static void showSum();
};

Car::Car()
{
    num=0;
    gas=0.0;
    sum++;
    cout << "車を作成しました。" << endl;
}

void Car::setCar(int n, double g)
{
    num=n;
    gas=g;
    cout << "ナンバーを" << num << "に、ガソリン量を" << gas << "にしました。" << endl;
}

void Car::showSum()
{
    cout << "車は全部で" << sum << "台あります。" << endl;
}

void Car::show()
{
    cout << "車のナンバーは" << num << "です。" << endl;
    cout << "ガソリン量は" << gas << "です。" << endl;
}

int Car::sum=0;

int main()
{
    Car::showSum();

    Car car1;
    car1.setCar(1234,20.5);

    Car::showSum();

    Car car2;
    car2.setCar(4567,30.5);

    Car::showSum();

    return 0;
}

実行結果は、車の台数が0,1,2と増えていきます。

ただstatic関数はクラスに紐づけられているため、

特定のオブジェクトに関連したメンバにアクセスすることはできませーん。

はい。以上！

卒論発表練習やんねーと。

勉強は毎日してるんだけどね。

ま、そんな言い訳はよくて、苦手分野であることが発覚した文字列行きましょう。今日は。

「独習Ｃ＋＋」の第１章理解度チェックにもあった、

関数のオーバーロード兼文字列を逆順に返す関数を作成します。

char s1[80], s2[80];

strcpy(s1,"hello");

rev_str(s1,s2); // 逆順にした文字列をs2に格納

rev_str(s1); //逆順にした文字列をs1に返す

これが前提条件どす。

もう分からなくなって答えみちゃった(笑)

終了するために'\0'とNULL文字を加えるところで詰んでました。

この１文ないだけで、出力が↓こうなって恐怖でした。

#include <iostream>

using namespace std;

void rev_str(char *s1);
void rev_str(char *s1, char *s2);

int main()
{
    char s1[80], s2[80];

    strcpy(s1,"hello world");

    rev_str(s1);
    rev_str(s1,s2);

    return 0;
}

void rev_str(char *s1)
{
    char tmp[80];
    int i,j;
    for(i=strlen(s1)-1,j=0;i>=0;i--,j++){
        tmp[j]=s1[i];
    }
    tmp[j]='\0';

    cout << tmp << endl;
}

void rev_str(char *s1, char *s2)
{
    int i,j;
    for(i=strlen(s1)-1, j=0; i>=0; i--, j++){
        s2[j]=s1[i];
    }
    s2[j]='\0';
    
    cout << s2 << endl;

}

文字列の復習にも時間を費やさなければ。

はい。以上！

彼らがアプリを作る理由は「モテたいから」だそうです。

なんか、かっこいいなと思ってしまったのは置いといて今日はクラスです。

オブジェクト指向言語ならではの機能じゃないでしょうか。

「やさしいＣ＋＋」の１２章練習問題からピックアップしてきました。

x,y座標を指定するプログラムです。

クラス（設計図）では、

座標x,y　・・・　ともに0～10で設定し、それを超える場合は0に

ほかのメンバ関数では、座標の設定（set）と、座標の獲得(get)です。

class Point{
private:
    int x;
    int y;
public:
    void setX(int a);
    void setY(int b);
    int getX(){return x;}
    int getY(){return y;}
};

void Point::setX(int a)
{
    if(a>=0 && a<=10){
        x=a;
    }else{
        x=0;
    }
}

void Point::setY(int b)
{
    if(b>=0 && b<=10)
        y=b;
    else
        y=0;
}

private関数に座標を指定することで、外部からの下手な操作の影響を受けないようにカプセル化しています。（オブジェクト指向ならでは？？）

そのため、privateをいじるには、同じクラスに指定されているメンバ関数を経由する必要があります。

次にメイン関数です。

int main()
{
    Point p;
    int x, y;

    cout << "X座標を入力してください。" << endl;
    cin >> x;
    p.setX(x);

    cout << "Y座標を入力してください。" << endl;
    cin >> y;
    p.setY(y);

    cout << "座標は(" << p.getX() << "," << p.getY() << ")です。" << endl;

    return 0;
}

set関数でprivateにアクセスして、

get関数でprivateから値を拾ってきています。

個人的に、publicと比較して手間がすごいなと思ったんですが。

特に、cin>>x;からのp.set(x);これ。

cin>>から直接渡したいのにそれはできないのか。

まぁ、この手間を覆すほどの見返りはあると思いますが、まだ腑に落ちない部分です。

今後、クラスを多様していけば見方が変わるのだろうか。

はい。以上です。

あんま気にしたことないんだよなぁ。

でも大型のプログラムになってくると避けては通れない道です。

研究でディープニューラルネットワークを扱っているんですが、

メモリ確保がうまくいかないと「セグメント例外」とかいう悪魔のメッセージを吐き出しますね。

じゃあ早速やってみます。

簡単に、人数分を聞いてテストの点数を入力し、出力するだけのプログラムです。

メモリの確保はnewを、解放はdeleteを使います。

int main(void)
{
    int num;
    int* pT;

    cout << "何人のテストの点数を入力しますか？" << endl;
    cin >> num;

    pT=new int[num];

    cout << "人数分の点数を入力してください。" << endl;

    for(int i=0;i<num;i++){
        cin >> pT[i];
    }

    for(int j=0;j<num;j++){
        cout << j+1 << "番目の人の点数は" << pT[j] << "です。" << endl;
    }

    delete[] pT;

    return 0;

}

int* pTでポインタを作成し、

pT=new int[num]

でnum分のメモリを配列で確保します。

あとは配列の扱いですね。

最後には

delete[] pT

と解放するのを忘れないようにしましょう。

はい。以上です。

ってことで、今日はグローバル変数とローカル変数です。

簡単に言えば、関数の中で宣言するか、外で宣言するかの違いです。

外で宣言した場合は、どの関数内でも使えます（グローバル変数）

中で宣言した場合は、その関数内でしか使えません（ローカル変数）

グローバル変数とローカル変数を同じ変数名にして宣言し、

何かしらの操作をした場合どちらが優先されるのでしょうか。

関数内ではローカル変数に上書き（？）されるようです。

そこでローカル変数を扱いたい場合は「::」というグローバル解決演算子を使用します。

そこでひとつ検証してみました。

自分の中でいまいち腑に落ちていなかった「a++」と「++a」の解決もできました。

#include <iostream>

using namespace std;

int a=2;

 

int main(void)
{
    int a=4;

    cout << ++a << endl;
    cout << ::a++ << endl;

    return 0;

}

実行結果は、5と2が出てきます。

前置インクリメント「++a」は1増やしてからcoutする

後置インクリメント「a++」はcoutしてから1増やす

という違いがあります。

そのため、::a++は2と表示されたわけですね～。

Ｃ言語で理解してたつもりでしたけど、意外と盲点？な気がします(笑)

しませんか。はい。以上です。

今回はポインタについて勉強していきます。

簡単に言えば、アドレスを直接扱うものとして考えられたのがポインタですね。

関数を使うときには、値渡しと参照渡しとがありますが、気を付けなければなりません。

試しに数値を入れ替えるswap関数について。

void swap(int a,int b)

{

int tmp=a;

a=b;

b=tmp;

}

はい。この関数は一時的な変数tmpを用意してint型変数aとbの数値を交換するものです。

しかし、このような値渡しでは、aとbの数値交換はこの関数でのみ終結してしまい、

呼び出したとしても値が変更しないという問題が生じます。

ここでは、ポインタを使ってアドレス操作することにより、

数値を交換する参照渡しをする必要があります。

void swap(int* pA, int* pB)

{

int tmp=*pA;

*pA=*pB;

*pB=tmp;

}

ちなみにmain関数では、

swap(&a, &b);

というようにアドレスを渡します。

ポインタの基本なので、応用がきくともっと便利さが伝わってくるのかなと期待しています。。

全体の関係性は、

a　と *pA

&a　と　pA

のようになっています。

ポインタはある数値のアドレスを扱うことができるってことですね～

はい。以上！

「やさしいＣ＋＋」で学んだ内容を強化するために使っていこうと思っています。

今回は、演習問題からキューについて見ていきます。

数年前に学校の課題でやった覚えがあります。

当時は、頭のいい友達に呆れられながら教えてもらった覚えがあります。

うろ覚えでしたが、構造を考えながら書いてみたら、

案外すんなり書けました（汚いプログラムが）。

#include <iostream>

using namespace std;

#define N 100

class queue{
    int q[N];
    int head,tail;
public:
    void init();
    void enqueue(int num);
    int dequeue();
};

void queue::init()
{
    head=0;
    tail=0;
    for(int i=0;i<N;i++)
        q[i]=0;
}

void queue::enqueue(int num)
{
    if(tail==N-1)
    {
        cout << "キューはいっぱいです。" << endl;
        return;
    }
    q[tail]=num;
    tail++;
}

int queue::dequeue()
{
    if(tail==head)
    {
        cout << "キューは空です。" << endl;
        return 0;
    }
    tail--;
    
    int a;
    a=q[head];
    
    for(int i=1;i<=tail;i++){
    q[i-1]=q[i];
    }

    return a;
}

int main(void)
{
    queue q1;

    q1.init();

    q1.enqueue(1);
    q1.enqueue(2);
    q1.enqueue(3);
    q1.enqueue(4);

    cout << q1.dequeue() <<endl;
    cout << q1.dequeue() <<endl;
    cout << q1.dequeue() <<endl;
    cout << q1.dequeue() <<endl;

    return 0;

}

何年後かに見たら笑えるプログラムなんでしょうな。

スタックと違うところは、先入れ先出しのところで、

キューの先頭の値を変更（詰める）する部分ですかね。

独習のほうでは、循環させるリングバッファー型でしたが、

ふつうのキュー作りました。

はい。以上です。