제 3 장 함수와 변수
선언 및 정의
선언: 메모리를 할당하지 않고 단순히 특성을 컴파일러에게 알려주기만 한다.
정의: 메모리를 할당하고 그곳에 값을 저장할 수 있도록 준비한다.
3.1 함수(function)
함수는 특정 동작을 수행하도록 작성된 독립된 프로그램으로 함수끼리는 인수를 통해 서로 정 보를 교환한다. 모듈(Module) 또는 파일(file)은 특정한 일을 하도록 꾸며진 함수들의 집합이 다.
• 표준 함수(standard library function): C/C++언어체계에 정의된 함수로 어떤 목적을 위해 미리 만들어진 코드.
• 사용자 정의함수(programmer defined function): 사용자가 만든 함수.
3.1.1 함수의 선언 및 정의
함수의 정의
자료형 함수명(가인수) { 함수몸체 } 예) int fn(int x, int y) { ... }
• 자료형: 함수가 반환하는 값의 형태이며 생략되면 int를 뜻한다. 또한 void는 반환 값이 없 는 함수를 정의할 때 사용한다.
• 가인수(dummy parameter): 호출시 값을 넘겨받는 일종의 변수로 자료형을 갖는다. 받는 인
수가 없을 때 가인수 목록은 없고 단순히 void fn() { ... }처럼 정의한다.
• 함수 몸체: 함수가 해야 할 일을 나열하는 곳으로 중괄호로 묶으며, 함수몸체 속에는 다음 과 같은 내용을 갖는다.
지역 선언문(local declaration) + 복합문 + return
return은 호출 쪽에 반환 값과 실행제어를 돌려주며 형태는 다음과 같다.
- return; 제어만 운영체제에 반환, 함수형식은 void 로 return은 생략이 가능하다.
- return (식); 식 결과를 호출한 환경으로 돌려주고 제어가 반환. 함수의 자료형은 바로 함 수가 반환하는 자료의 형태이다.
함수의 선언
함수의 선언은 몸체가 없이 단지 컴파일러가 그 함수를 인지할 수 있도록 특성만 기술한다.
예) int fn(int x, int y) 또는 인수 없이 int fn(int, int)
3.1.2 main()과 함수의 호출
main()은 프로그램의 중심이 되는 함수로 시작과 종료를 이끌며 다른 함수의 초기 호출은 main()에서 이루어진다.
호출 형식
main() 또는 다른 함수 속에서 그 함수이름으로 호출.
호출형식: 함수이름(인수 목록) 호출 및 반환의 도식
{ return result; } { r=fn(x,y); }
main() fn(a, b)
인수전달
결과 값 반 환
• 호출자(caller) main()에서 피 호출자(callee) fn()을 호출시, main()내 fn(x,y)의 실인수 x, y가
가인수 fn(a,b)의 a, b에 1:1로 대응되어 전달된다. 실인수는 상수, 변수, 식 모두 가능하다.
• 피 호출자 fn(a,b)는 호출자로부터 받은 인수로 계산이나 프로그램을 돌려 그 결과를 호출 자에
게 넘겨준다.
• 반환 값 자료형은 호출문이 있는 위치의 자료형과 같아야 한다. 즉 돌려주는 값의 결과가 함수 의 자료형 이여야 한다.
• 호출자는 피 호출자의 결과 값을 반환받아 실행을 계속한다.
예제 1) 반환 값이 없는 void형 함수의 호출
#include <stdio.h>
void fn() {
int i, s, z=3;
for(i=1; i<=z; i++) { s=i*i;
printf("s=%d\n",s);
} }
void main() { fn();
}
#include <iostream.h>
void fn() {
int i, s, z=3;
for(i=1; i<=z; i++) { s=i*i;
cout<<"s="<<s<<'\n';
} }
void main() { fn();
}
설명: 반환 값이 없는 fn()을 호출하면 main()이 호출한 자리에서 fn()을 수행하고 종료한다.
예제 2) 반환 값이 없는 함수의 선언 및 호출
#include <stdio.h>
void fn2(); // 전방참조 함수선언
void fn1() {
printf("1) main() 속에서 호출한 fn1()\n");
fn2(); // fn2()의 선언이나 정의가 미리 되어 있어 전방참조가 가능해야함.
}
void main() {
fn1(); // fn1()을 호출
}
void fn2() { // fn2()의 정의.
printf("2) fn1()에서 호출한 fn2() \n\n");
}
#include <iostream.h>
void fn2(); // 전방참조 함수선언
void fn1() {
cout<<"1) main() 속에서 호출한 fn1()\n";
fn2(); // fn2()의 선언이나 정의가 미리 되어 있어 전방참조가 가능해야함.
}
void main() {
fn1(); // fn1()을 호출
}
void fn2() { // fn2()의 정의.
cout<<"2) fn1()에서 호출한 fn2() \n\n";
}
설명: main()에서 fn1()을 호출하고, fn1()이 그 속에서 다시 fn2()를 호출하고 있다. 그러나 fn(2)는 fn1()에 앞서 몸체가 없기 때문에 함수선언으로 표기되는 전방참조를 하였다. 함수가 호출되어 작동하려면 그 함수는 호출자보다 앞에 선언이나 정의가 되어 있어야 하며, 만일 선 언이 있을 경우 호출되는 함수의 정의는 어느 곳에 있어도 상관없다. 이 프로그램에서는 fn1()내에서 fn2()를 호출하고 있기 때문에 전방참조를 위하여 fn2()를 선언하였고 main()뒤에 정의하였다.
예제 3) 반환 값이 있는 함수의 호출과 반환
#include <stdio.h>
int fn(int a, int b) { int z;
z=a-b;
return z;
}
void main() { int i, r;
int x=10, y=6;
r=fn(x, y); // r=4
for(i=2; i<=r; i++) { int j=1;
while(j<=r) {
printf("%d x %d =%d\t\n", i, j, i*j);
j++;
} putchar('\n');
} }
#include <iostream.h>
int fn(int a, int b) { int z;
z=a-b;
return z;
}
void main() { int i, r;
int x=10, y=6;
r=fn(x, y); // r=4
for(i=2; i<=r; i++) { int j=1;
while(j<=r) {
cout<<i<<" x "<<j<<"="<<i*j<<"\n";
j++;
} cout<<'\n';
} }
설명: main()에서 r=fn(x,y)는 실인수 x=10, y=6으로 int fn(int a, int b)를 호출하고 있다.
호출된 함수는 그 실인수를 가인수 a=10, b=6으로 각 각 넘겨받아 함수몸체 안에서 계산을 한다. 그리고 그 결과 값 z=4를 r=fn(x,y)로 돌려주어 r=4가 된다. 여기서 주목할 것은 실인 수 x, y가 int 이므로 넘겨받을 가인수 a, b는 fn(int a, int b)로, 돌려주는 값 4 역시 int 이 므로 int fn(int a, int b)로 각 각 자료형이 정의되었다.
예제 4) 함수 호출과 반환 (최소 값 구하기)
#include <stdio.h>
int fn(int x, int y, int z) { int min;
min=(x<y) ? x : y;
min=(min<z) ? min : z;
return min;
}
void main() {
int a=5, b=3, c=7;
int t;
t=fn(a,b,c);
printf("min=%d\n",t);
}
#include <iostream.h>
int fn(int x, int y, int z) { int min;
min=(x<y) ? x : y;
min=(min<z) ? min : z;
return min;
}
void main() {
int a=5, b=3, c=7;
int t;
t=fn(a,b,c);
cout<<"min="<<t<<"\n";
}
3.1.3 재귀적 호출(Recursive call)
같은 함수를 반복 호출하는 것을 재귀적 호출이라 한다.
예제 1) 재귀 호출에 의한 factorial의 계산
# include <stdio.h>
int fact(int ); // 전방참조 함수선언(변수의 자료형 만 기술해도 됨) void main() {
int a;
a=fact(4); // 1st_return: 4*fact(3) a=4*fact(3)
// 2nd_return: 3*fact(2) a=4*3*fact(2) // 3rd_return: 2*fact(1) a=4*3*2*fact(1)
// 4th_return: if(n==1) 수행 a=4*3*2*1:호출 없음-다음줄 수행
printf("4!=%d\n",a);
}
int fact(int n) {
if(n==1) // 종료조건
return 1;
else
return n*fact(n-1); // 함수 속 인수가 감소단계를 가져야함 }
# include <iostream.h>
int fact(int n); // 함수선언(변수의 자료형만 기술해도 됨) void main() {
int a;
a=fact(4); // 1st_return: 4*fact(3) a=4*fact(3)
// 2nd_return: 3*fact(2) a=4*3*fact(2) // 3rd_return: 2*fact(1) a=4*3*2*fact(1)
// 4th_return: if(n==1) 수행 a=4*3*2*1:호출 없음-다음줄 수행
cout<<"4!="<<a<<'\n';
}
int fact(int n) {
if(n==1) // 종료조건
return 1;
else
return n*fact(n-1); // 인수가 항상 감소단계를 가져야함 }
무한 루프를 방지하기 위하여 재귀호출은 호출될 때마다 인수가 감소되어야 한다. 인수가 증 가하면 무한반복으로 에러발생.
예제2) factorial 계산: 재귀호출의 조건연산자 사용
#include <stdio.h>
int facto(int n) {
return (n==0) ? 1 : n*facto(n-1);
}
void main() { int i=0;
do
printf("%d!=%d\n",i,facto(i));
while(i++<4);
}
#include <iostream.h>
int facto(int n) {
return (n==0) ? 1 : n*facto(n-1);
}
void main() { int i=0;
do
cout<<i<<"!="<<facto(i)<<'\n';
while(i++<4);
}
3.2 변 수
3.2.1 변수선언
지역변수(local variable): 함수 내에서 선언된 변수
전역(global variable) 또는 외부변수: 함수 밖에서 선언된 변수
변수에 대한 선언 및 정의 그리고 그 위치는 일반적으로 다음의 구조를 갖는다.
#include <stdio.h>
int a; // 외부변수로 선언. 다른 file에서도 사용가능
extern int b; // 외부변수로 b는 다른 file에 정의 되어 있음 static int c; // 외부정적 변수의 선언. 다른 file에서 사용불가.
void main() {
auto int d; // 지역 자동변수의 선언. auto는 생략가능 static int e; // 지역 정적변수 선언.
register int f; // 지역 register 변수 선언.
}
3.2.2 변수선언과 유효범위
1) 정적영역(Static 영역)
program의 실행이 종료되면 소멸하는 변수들로 정적(static), 외부(extern), 전역(global) 변 수들이 이곳에 할당된다. 초기화는 컴파일 시 단 한번만 이루어진다.
• 정적변수(static variable)
내부 정적변수: 함수 내에서 선언하고 함수 내에서만 유효.
외부정적변수: 함수 밖에서 선언하고 다른 함수에서도 참조. 단 다른 module서는 사용불 가,
• 전역변수(global variable)
함수 밖에서 선언하고 프로그램내의 모든 함수에 유효. 다른 module에서 참조 시 extern 사용.
• extern 변수(external variable): 다른 module에 선언된 전역 변수의 참조.
정적 및 전역변수는 초기화 하지 않으면 default 값으로 초기화 된다. 즉 0(for int), 0.0(for double), NULL(for char)이 자동 입력된다.
함수 내 자동변수와 register 변수를 제외한 모든 변수들은 static영역에 저장되고 영역의 번 지수는 오름차순이다.
2) Stack 영역
함수가 종료되면 소멸하는 변수들로 자동변수(auto variable)가 이곳에 할당되며 함수가 실행 될 때마다 초기화가 행해진다. 다른 함수 또는 다른 블록(block)에서 똑같은 이름을 사용한다 고 해도 그것은 다른 변수이며 서로 영향을 주지 않는다. 자동변수는 선언과 함께 초기화가 항상 필요하다. stack은 메모리에서 번지수가 하향으로 증가한다.
3) CPU 내의 register 영역
register 변수는 자동변수와 역할이 동일하고 단지 CPU내에 저장된다는 것이 다르다.
3.2.3 함수 내부의 자동변수와 정적변수
함수내부에서 아무런 예약어(keyword)가 없는 변수는 모두 자동변수이다. 이들은 선언 시 초 기화가 필요하며 함수가 종료되면 사라지고 호출되면 다시 초기화 한다. 이와 달리 정적변수 는 프로그램이 시작될 때 한번만 초기화되고 함수가 종료되어도 그대로 있으며 프로그램이 종 료될 때 사라진다.
예제 1) 자동변수(auto variable)
#include <stdio.h>
void sum(int ); // 함수선언
void main() { int i;
for(i=1; i<=3; i++) sum(i);
}
void sum(int n) {
int a=0, t; // a는 main()에서 sum()이 호출될 때마다 0으로 초기화 됨.
printf("a=%d\n",a);
t=a; // a를 t에 배정. 즉 a값과 t값은 같다.
a=t+n; // sum(1): a=0+1=1 // sum(2): a=0+2=2 // sum(3): a=0+3=3 printf(" a=%d+%d\n",t,n);
}
#include <iostream.h>
void sum(int ); // 함수선언
void main() { int i;
for(i=1; i<=3; i++) sum(i);
}
void sum(int n) {
int a=0, t; // a는 main()에서 sum()이 호출될 때마다 0으로 초기화 됨.
cout<<"a="<<a<<'\n';
t=a; // a를 t에 배정. 즉 a값과 t값은 같다.
a=t+n; // sum(1): a=0+1=1
// sum(2): a=0+2=2 // sum(3): a=0+3=3 cout<<" a="<<t<<'+'<<n<<'\n';
}
예제 2) 정적변수(static variable)
#include <stdio.h>
void sum(int ); // 함수선언
void main() { int i;
for(i=1; i<=3; i++) sum(i);
}
void sum(int n) {
static int a=0; /* a는 프로그램이 시작될 때 0으로 초기화되고 sum()이 호출되고 나서 종료되어도 a방을 유지 */
int t;
printf("a=%d\n",a);
t=a; // a를 t에 배정. 즉 a값과 t값은 같다.
a=t+n; // sum(1): a=0+1=1
// sum(2): a=1+2=3 // sum(3): a=3+3=6
printf(" a=%d+%d\n",t,n);
}
#include <iostream.h>
void sum(int ); // 함수선언
void main() { int i;
for(i=1; i<=3; i++) sum(i);
}
void sum(int n) {
static int a=0; /* a는 프로그램이 시작될 때 0으로 초기화되고 sum()이 호출되고 나서 종료되어도 a방을 유지 */
int t;
cout<<"a="<<a;
t=a; // a를 t에 배정. 즉 a값과 t값은 같다.
a=t+n; // sum(1): a=0+1=1
// sum(2): a=1+2=3 // sum(3): a=3+3=6 cout<<" a="<<t<<'+'<<n<<'\n';
}
설명: static으로 선언된 변수는 프로그램이 실행하는 동안 한번만 초기화하며 호출될 때마다 누적된 값을 유지하고 있다.
예제 3) 정적과 자동변수의 비교
#include <stdio.h>
void fn() {
static int i;
int j=1;
printf("i=%d j=%d\n", i,j);
i++;
j++; } void main() {
int k;
printf("static auto\n");
printf("---\n");
for(k=0;k<3;k++) fn();
/* fn()을 세 번 호출. fn()내의 static int i는 호출 될 때마다 1씩 증가하고 auto int j는 그때마다 새로 초기화함으로 항상 j=1이다. 결과는 다음과 같다.
static auto
--- i=0 j=1 i=1 j=1 i=2 j=1 */
}
#include <iostream.h>
void fn() {
static int i;
int j=1;
cout<<"i="<<i<<" j="<<j<<'\n';
i++;
j++; } void main() {
int k;
cout<<"static auto\n";
cout<<"---\n";
for(k=0;k<3;k++) fn();
/* fn()을 세 번 호출. fn()내의 static int i는 호출 될 때마다 1씩 증가하고 auto int j는 그때마다 새로 초기화함으로 항상 j=1이다. 결과는 다음과 같다.
static auto --- i=0 j=1 i=1 j=1 i=2 j=1 */
}
예제 4) 변수의 사용 범위
#include <stdio.h>
void fn1(); // 함수선언
void fn2(); // 함수선언
void main() { int i=7;
fn1(); // fn1()은 자신의 i를 사용: i=1
printf("main()의 i=%d\n", i); // main()의 i=7
i=i+3; // main()의 i=7을 사용
fn2(); // fn2()의 i=2, j=3
// i+j=2+3=5 printf("main()의 i=%d\n", i); // main()의 i=10
fn2(); // fn2()의 i=2. i, j를 재 초기화하였으므로 첫 호출과 같
음.
// i+j=2+3=5 }
void fn1() { int i=0; i++; printf("fn1()의 i=%d\n",i); } void fn2() {
int i=2, j=3;
printf("fn2()의 i+j=%d+%d=%d\n\n",i,j,i+j);
}
#include <iostream.h>
void fn1(); // 함수선언
void fn2(); // 함수선언
void main() { int i=7;
fn1(); // fn1()은 자신의 i를 사용: i=1
cout<<"main()의 i="<<i<<'\n'; // main()의 i=7
i=i+3; // main()의 i=7을 사용
fn2(); // fn2()의 i=2, j=3
// i+j=2+3=5 cout<<"main()의 i="<<i<<'\n'; // main()의 i=10
fn2(); // fn2()의 i=2. i,j를 재 초기화하였으므로 첫 호출과 같 음.
// i+j=2+3=5 }
void fn1() { int i=0;
i++;
cout<<"fn1()의 i="<<i<<'\n';
}
void fn2() {
int i=2, j=3;
cout<<"fn2()의 i+j="<<i<<'+'<<j<<'='<<i+j<<"\n\n";
}
설명: 각 함수에 있는 변수는 이름이 같다고 해도 서로 다른 변수이며, 사용범위는 그 함수 내에서만 유용하다. 자동변수는 함수가 호출될 때 마다 다시 초기화함으로 fn2()의 첫 호출과 두 번째 호출의 결과는 같다.
3.2.3 전역변수
함수외부에서 선언된 변수(전역변수)는 모든 함수에서 사용할 수 있으나 만일 함수 내에 같은
이름의 변수가 있다면 그 함수는 자신의 지역변수를 우선 사용한다. 전역변수는 프로그램이 시작될 때 스스로 0으로 초기화하며 프로그램이 끝날 때까지 자신의 방을 유지한다.
예제 1) 전역 변수
#include <stdio.h>
void fn1();
void fn2();
int i; // 전역변수 정의. i=0로 자동 초기화됨.
void main() {
int i=5, s; // 지역 자동변수
fn1();
fn2();
s=i+3; // 내부 지역변수 i를 사용. 지역변수 우선.
printf("내부 i 사용. i+3=%d+3=%d\n\n",i,s); // i=8
}
void fn1() {
++i; // 호출된 fn1()은 외부 i를 1증가시킴.
printf("fn1()은 외부 i사용. i=%d\n", i); // i=1 }
void fn2() {
++i; // 호출된 fn2()역시 외부 i를 1증가시
킴.
printf("fn2()도 외부 i사용. i=%d\n", i); // i=2 }
#include <iostream.h>
void fn1();
void fn2();
int i; // 전역변수 정의. i=0로 자동 초기화됨.
void main() { int i=5, s;
fn1();
fn2();
s=i+3; // 내부 지역변수 i를 사용. 지역변수 우선.
cout<<"내부 i 사용. i+3="<<i<<"+3="<<s<<"\n\n"; // i=8 }
void fn1() {
++i; // 호출된 fn1()은 외부 i를 1증가시킴.
cout<<"fn1()은 외부 i사용. i="<<i<<'\n'; // i=1 }
void fn2() {
++i; // 호출된 fn2()역시 외부 i를 1증가시킴. i=2
cout<<"fn2()도 외부 i사용. i="<<i<<'\n'; // i=2 }
설명: 전역 변수로 선언된 int i는 fn1()과 fn2()가 공동으로 사용하는 변수이므로 두 함수가 main()에서 호출될 때마다 외부 i는 1씩 증가한다. main()내의 i는 이것과 관계없는 main() 내에서만 사용하는 자동변수이다. 다른 file에서 전역변수 i를 사용하려고 한다면 그 file에서 extern int i로 선언하여 사용할 수 있다. 만일 전역변수를 static int i로 선언했다고 한다면 결과는 전역변수와 똑 같으며 단지 차이점은 다른 file에서 사용할 수 없다는 것이다.
.
예제 2) 전역변수와 지역변수의 사용
#include <stdio.h>
int i=1; // 전역변수
void fn1();
void fn2();
void main () {
++i; // 외부 i를 1증가시킴: i=2
fn1(); /* fn1()을 호출하여 외부 i를 1증가시킴 i=3.
그 속에서 다시 fn2()를 호출. fn2()의 내부 정적변수 i=11 */
printf("main()이 사용 중인 외부 i=%d\n",i); // i=3
fn2(); // fn2()를 호출. fn2()의 정적변수 i=12 }
void fn1() { i++;
printf("fn1()이 사용 중인 외부 i=%d\n",i);
fn2(); // fn1()내에서 fn2()를 호출.
}
void fn2() {
static int i=10;
i++;
printf("fn2()의 내부 정적변수 i=%d\n\n",i);
}
#include <iostream.h>
int i=1; // 전역변수
void fn1();
void fn2();
void main () {
++i; // 외부 i를 1증가시킴: i=2
fn1(); /* fn1() 호출하여 외부 i를 1증가시킴 i=3.
그 속에서 다시 fn2()를 호출. fn2()의 내부 정적변수 i=11 */
cout<<"main()이 사용 중인 외부 i="<<i<<'\n'; // i=3
fn2(); // fn2()를 호출. fn2()의 정적변수 i=12 }
void fn1() { i++;
cout<<"fn1()이 사용 중인 외부 i="<<i<<'\n';
fn2(); // fn1()내에서 fn2()를 호출.
}
void fn2() {
static int i=10;
i++;
cout<<"fn2()의 내부 정적변수 i="<<i<<"\n\n";
}
설명: main()과 fn1()은 전역변수 i를 공동으로 사용하고 있다. main()이 실행되면 우선 ++i;
가 실행되어 전역변수 i가 1증가한다. 그 다음 fn1()을 호출하면 fn1() 내에서 i++; 가 역시 실 행되어 전역변수 i가 다시 1증가하고 i=3이 된다. 그리고 fn1()은 그 내부에서 fn2()를 호출하 고 있다. 이때 fn2()는 자신의 지역 정적변수인 i를 사용하므로 그 값은 i=11이 된다. 이것은 전역변수 i와는 완전히 다른 변수이다. 그리고 프로그램은 마지막으로 독립된 fn2()를 호출하 고 있으므로 최종적으로 fn2()의 i는 i=12가 된다.
변수 선언 연습 프로그램
연습 1) 전역, 지역 및 정적변수의 연습
#include <stdio.h>
int i=2;
void fn1();
void fn2();
void main() {
printf("global i=%d\n", i); //global i=2
i=5; // global i에 5 대입
fn1(); // global i=5를 1증가시킴 i=6, j=1, k=1
fn2(); // global i=6을 1증가시킴 i=7
fn1(); // global i=7을 1증가시킴 i=7, j=1. k=2
}
void fn1() {
int j=0; static int k=0;
i++; j++; k++;
printf("fn1(): i=%d, j=%d, k=%d\n", i,j,k);
}
void fn2() {
i++;
printf("fn2(): i=%d\n", i);
}
#include <iostream.h>
int i=2;
void fn1();
void fn2();
void main() {
cout<<"global i="<<i<<'\n'; //global i=2
i=5; // global i에 5 대입
fn1(); // global i=5를 1증가시킴 i=6, j=1, k=1
fn2(); // global i=6을 1증가시킴 i=7
fn1(); // global i=7을 1증가시킴 i=7, j=1. k=2
}
void fn1() {
int j=0; static int k=0;
i++; j++; k++;
cout<<"fn1(): i="<<i<<" j="<<j<<" k="<<k<<'\n';
}
void fn2() { i++;
cout<<"fn2(): i="<<i<<'\n';
}
연습 2) 변수사용 범위 test
#include <stdio.h>
void main() { int d=10;
{
double d=3.14;
printf("inner d=%.2lf\n",d);
}
printf("outer d=%d\n",d);
}
#include <iostream.h>
void main() { int d=10;
{
double d=3.14;
cout<<"inner d="<<d<<'\n';
}
cout<<"outer d="<<d<<'\n';
}
연습 3) extern으로 선언된 변수
#include <stdio.h>
void fn(); // 전역변수로 main()과 fn()에서 모두 사용.
int a=1;
void main() {
extern int b; /* 변수 b는 전방참조가 불가능하고 뒤에 외부변수로 정의
되어 있어 여기서 사용하려면 keyword extern을 필요로 한다.
*/
printf("a=%d\n",a);
printf("b=%d\n",b);
fn();
}
int b=2;
void fn() {
printf("a=%d\n",a);
printf("b=%d\n",b);
}
#include <iostream.h>
void fn();
int a=1; // 전역변수로 main()과 fn()에서 모두 사용.
void main() {
extern int b; /* 변수 b는 전방참조가 불가능하고 뒤에 외부변수로 정의
되어 있어 여기서 사용하려면 keyword extern을 필요로 한다. */
cout<<"a="<<a<<'\t'<<"b="<<b<<'\n';
fn();
}
int b=2;
void fn() {
cout<<"a="<<a<<'\t'<<"b="<<b<<'\n';
}
extern으로 선언하는 변수는 연습에서 보여준 방법 외에도 다른 file속에 있는 전역변수를 쓸 경우, 똑같은 방법 즉 extern double c 등으로 선언하여 사용할 수 있다.
예제 4) 전역, static변수의 자동초기화
#include <stdio.h>
int g; // 전역변수는 0으로 자동초기화.
static int s; // 외부 정적변수는 0으로 자동초기화.
static char c; // 외부 정적 문자변수는 NULL로 자동초기화.
void main() {
static int a; // 내부 정적변수는 0으로 자동초기화.
static char ch; // 내부 문자변수는 NULL로 자동초기화.
int b=1; // 자동변수는 초기화를 해주어야함.
printf("전역 변수 g=%d\n",g);
printf("외부 정적 변수 s=%d\n",s);
printf("외부 정적 문자변수 c=%c\n",c);
printf("내부 정적 변수 =%d\n", a);
printf("내부 정적 문자변수 s=%c\n", ch);
printf("자동 변수 b=%d\n", b);
}
설명: 자동변수를 제외하고 전역과 정적변수는 자동으로 초기화된다.
