🌻天国にいけるC++言語入門🌻 進化し続けるオブジェクト指向プログラミング ver3.2307

変数のスコープと変数の寿命について学んでいきましょう。これらが理解できると どの位置で変数宣言をおこなえばよいのかがよくわかるようになります

🌞自作関数１１ グローバル変数は 異なる関数同士でも共通して使えます そのグローバル変数のスコープ(使用可能な範囲）はグローバル変数宣言された行以下のプログラム全体となります

以前のエピソードで見てきたように

　🍎main関数と自作関数は異なる関数であり🍎

自作関数内で変数宣言された変数a

と

main関数内で変数宣言された変数aは

別の変数扱いとなり

自作関数内で変数宣言された変数aに格納されている値を変化させても

main関数内で変数宣言された変数aに格納されている値は影響をうけません。

逆に

main関数内で変数宣言された変数aに格納されている値を変化させても

自作関数内で変数宣言された変数aに格納されている値は影響をうけません。

それでは

異なる関数同士でも共通して使える変数を設定するには

どうしたらよいのでしょうか？

てんC　「その場合は　次のプログラムの

int a=1;のように👇」

#include <iostream>

using namespace std;

int a=1;//👈ここで変数宣言をおこないます　この位置が大切です

void f(void){

cout << a << "をとりこみました。\n";

}

int main()

{

f();

cout << a << "をとりこみました。\n";

return 0;

}

ビルド実行結果

1をとりこみました。

1をとりこみました。

てんC「👆

main関数と自作関数の外でaの変数宣言、初期化をおこなえば

int a;

と変数宣言した行以下のすべての関数に

共通して使用できる変数aを設定することができます。」

ソーラー「

void f(int a){

cout << a << "をとりこみました。\n";

}

が

今のプログラムでは

int a;

void f(void){

cout << a << "をとりこみました。\n";

}

になったわけだね。

グローバル変数aを

自作関数f

main関数

でも共通して使用するので

void f(int a){

cout << a << "をとりこみました。\n";

}

の

ローカル変数aを生成するローカル変数宣言であるint aをvoidにして

printf("%dをとりこみました。\n",a);

の

変数a

が

ローカル変数aでなく

グローバル変数aの影響を受けるようにしたというわけなんだね。」

てんC「はい😊

void f(int a){

cout << a << "をとりこみました。\n";

}

のように

aのint型の変数宣言int aを()内で記述してしまうと

cout << a << "をとりこみました。\n";

の変数aは

ローカル変数宣言int aの影響を受けてローカル変数になるんです😊

そこで　void f(int a)のかわりにvoid f(void)と記述してあるのですね」

(ここでちょっと先のエピソードの内容を先取りすると）

#include <iostream>

using namespace std;

int a=1;//👈ここでaのグローバル変数宣言をおこないます　

　　　👇ここでもaのローカル変数宣言

void f(int a){

cout << a << "をとりこみました。\n";

}

int main(){・・・・・・・・・

・・・・・・・・・・

};

のように

aのグローバル変数宣言

と

自作関数fの定義内でaのローカル変数宣言

を

　　　　　　　　　🍋同時に実行すると🍋

グローバル変数宣言int aよりローカル変数宣言int a

の方が

優先されることになります

よって

void f(int a){

cout << a << "をとりこみました。\n";

}

のなかの

cout << a << "をとりこみました。\n";

の

a

は

ローカル変数宣言int aの影響をうけローカル変数aとなります

ソーラー　「そう、そして

グローバル変数は

変数宣言した行以下の関数に共通して使用できる変数なので

次のプログラムのように

プログラムの途中で

自作関数の定義の後

そして

main関数の定義の前で

int a=1;

と変数宣言を行った場合

#include <iostream>

using namespace std;

void f(void){

cout << a << "をとりこみました。\n";

}

int a=1;//👈自作関数の定義の後で変数宣言されているのがポイントです

int main(void)

{

f();

cout << a << "をとりこみました。\n";

return 0;

}

変数宣言した行より前の命令文である自作関数fの定義

👇

void f(void){

cout << a << "をとりこみました。\n";

}

の中の変数aには影響をあたえないので

void f(void){

cout << a << "をとりこみました。\n";

}

の中の変数aは定義されていないことになり　

上記のプログラムをこのままコンパイルするとコンパイルエラーがでます。

では

次のプログラム内の

　　　　　　int a=1;とint a=100;

は

どちらがローカル変数宣言でどちらがグローバル変数宣言でしょうか？」

#include <iostream>

using namespace std;

int a=1;//👈ここです

void f(void){

cout << a << "をとりこみました。\n";

}

int main()

{

int a=100;//👈ここちゃんです

f();

cout << a << "をとりこみました。\n";

return 0;

}

ビルド実行結果

1をとりこみました。

100をとりこみました。

ソーラー「

このプログラムの

自作関数の定義

void f(void){

cout << a << "をとりこみました。\n";

}

のなかの変数aと

main関数内の命令文

cout << a << "をとりこみました。\n";

のなかの変数aは名前は一緒でも

コンピュータには別の変数として認識されています。

なぜか？？

よくみると

int a=1;とint a=100;

の２つのaの変数宣言がおこなわれていますね。

この場合、同じ変数名aでも

int a=1;

により作成された変数a

と

int a=100;

により作製された変数aは

異なる変数として

コンピュータに認識されています。

そして

この場合

int a=1;がグローバル変数宣言

int a=100;がローカル変数宣言となっています。

グローバル変数宣言　int a=1;

は

自作関数やmain関数の外でおこなわれています。

それに対し

ローカル変数宣言　int a=100;

はmain関数のブロック{}内でおこなわれています。

通常Visual Studioでは

同じ関数内で同じ変数名を使って

変数宣言を2度おこなうことはできません。

ですが

グローバル変数宣言

と

ローカル変数宣言　

を行う際には

グローバル変数宣言　int a=1;

ローカル変数宣言　int a=100;

のように

同じ変数名aを使って変数宣言をおこなうことができます。

不思議ですね。

🌞プログラム全体に作用するグローバル変数宣言

int a=1;

と

main関数のブロック{}内で変数宣言されて

💖main関数のブロック{}内の変数aにのみ💖作用するローカル変数宣言

int a=100;

が行われた場合

main関数内の変数aは

aのグローバル変数宣言でなく

aのローカル変数宣言

int a=100;

の影響を優先してうけることになります

ですので

今のプログラム

👇

#include <iostream>

using namespace std;

int a=1;//👈ここです

void f(void){

cout << a << "をとりこみました。\n";

}

int main()

{

int a=100;//👈ここちゃんです

f();

cout << a << "をとりこみました。\n";

return 0;

}

のmain関数内の

cout << a << "をとりこみました。\n";

のaの格納する値は

main関数の{}内の

ローカル変数宣言int a=100;

の影響を受けて

100

となります

このように

グローバル変数宣言int a=1;

により作製された変数aと

ローカル変数宣言int a=100;

により作製された変数aは

別の変数とコンピュータに認識されていて

main関数のブロック{}内の変数aは

main関数のブロック{}の外で

実行された

グローバル変数宣言int a=1;

よりも

　　　　　　😸main関数のブロック{}内の😸

　　　　😸ローカル変数宣言int a=100;の影響を😸

　　　　　　😸優先してうけることになります😸

ですので

グローバル変数宣言

int a=1;

により作製された変数aに1が代入されていても

main関数のブロック{}内の

ローカル変数宣言

int a=100;

により作製された変数aに

1が代入されるようなことはないのですね

ではではっ

次のプログラムでは

どれが

グローバル変数宣言で

どれが

ローカル変数宣言でしょうか？」

#include <iostream>

using namespace std;

int a=1;//👈ここ

void f(void){

int a=2;//👈ここ

cout << a << "をとりこみました。\n";

}

int main()

{

int a=100;//👈ここ

f();

cout << a << "をとりこみました。\n";

return 0;

}

コンパイル結果

2をとりこみました。

100をとりこみました。

ソーラー「

この場合は

グローバル変数宣言

int a=1;

により変数宣言された変数aがグローバル変数

ローカル変数宣言

int a=2;

により変数宣言された変数aが自作関数のローカル変数

ローカル変数宣言

int a=100;

により変数宣言された変数aがmain関数のローカル変数と

なっています。

main関数のローカル変数宣言

int a=100;

が行われると

変数宣言がおこなわれたmain関数の🌞{}ブロック内🌞でのみ

そのローカル変数aは使用可能となります。

そのローカル変数aが使用可能な範囲をローカル変数aのスコープといいます

グローバル変数宣言

int a=1;

により作製された

グローバル変数aはグローバル変数宣言された行以下のプログラム全体で

使用可能になります。

そのグローバル変数が使用可能な範囲をグローバル変数aのスコープといいます

今のプログラムの場合では

#include <iostream>

using namespace std;

int a=1;👇

void f(void){

int a=2;

cout << a << "をとりこみました。\n";

}

int main()

{

int a=100;

f();

cout << a << "をとりこみました。\n";

return 0;👆

}

👇以下👆以上の行が

グローバル変数宣言

int a=1;

によって作製された

グローバル変数aのスコープとなります。

そして

#include <iostream>

using namespace std;

int a=1;

void f(void){👉

int a=2;

cout << a << "をとりこみました。\n";

👈}

int main()

{

int a=100;

f();

cout << a << "をとりこみました。\n";

return 0;

}

の

👉と👈のなかが

ローカル関数である自作関数のローカル変数宣言

int a=2;

によって作製される

ローカル変数aのスコープとなります。

そして

#include <iostream>

using namespace std;

int a=1;

void f(void){

int a=2;

cout << a << "をとりこみました。\n";

}

int main()

{

int a=100;👉

f();

cout << a << "をとりこみました。\n";

return 0;

👈}

の

int a=100;

以下の行の

{👉　　👈}のなかが

ローカル関数であるmain関数のローカル変数宣言

int a=100;

によって作製された

ローカル変数aのスコープとなります。」

てんC「グローバル変数宣言

int a=1;が

変数宣言された行以下が

グローバル変数aのスコープであるといっても

その後に　ある関数のブロック{}内で

ローカル変数宣言

int a=100;が

行われたならば

その関数のブロック{}内では変数aは

グローバル変数宣言

int a=1;でなく

ローカル変数宣言

int a=100;の影響をうけることになります」