따배씨 11.10 ~

11.10 명령줄 인수 Command-Line Arguments

-명령줄 인수는 프로그램 실행 시에 argument로 넣어줄 수 있다.

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main(int argc, char * argv[])
{
	int count;

	printf("The command line has %d arguments:\n", argc);

	for (count = 0; count < argc; count++)
		printf("Arg %d : %s\n", count, argv[count]);
	printf("\n");

	return 0;
}

명령줄 인수로서 문자열의 배열을 argv[]에 받아들이고 배열의 개수를 argc로 반환하는 코드

 

 

11.11 문자열을 숫자로 바꾸는 방법들

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[])
{
	/*
		string to integer, double, long
		atoi(), atof(), atol()
	*/

	if (argc < 3)
		printf("Wrong usage of %s\n", argv[0]);		//	배열의 1번째 메모리는 실행파일명
	else 
	{
		//	Example 1

		int times = atoi(argv[1]);	// 배열의 2번째 문자열을 정수로 바꿔 times에 대입
		//	atof(), atol()

		for (int i = 0; i < times; i++)
			puts(argv[2]);	// 배열의 3번째 문자열을 times에 들어온 정수만큼 출력

		//Example 2

		printf("Sum = %d\n", atoi(argv[1] + atoi(argv[2])));
	}

	/*
		string to long, unsigned long, double
		strtol(), strtoul(), strtod()

		strtod() converts base 10 only
	*/

	char str1[] = "1024Hello";
	char* end;
	long l = strtol(str1, &end, 10);	//	&end 이중포인터, 10 십진수
	printf("%s %ld %s %d\n", str1, l, end, (int)*end);
	// %s str1 : 변환하려는 문자열
    // %ld l : 숫자 부분만
    // %s end : strtol 에서 문자열을 숫자로 바꾸다가 변화할 수 없는 위치에 오면 그 포인터를 end에 넣어줌
    // %d (int)* end : 'H'에 해당하는 아스키숫자
	char str2[] = "10FFHello";
	l = strtol(str2, &end, 16);
	printf("%s %ld %s %d\n", str2, l, end, (int)* end);
	
	/*
		Numvers to strings
		Use strintf() instead of itoa(), ftoa()
	*/
	
	char temp[100];
	puts(_itoa(10, temp, 16));		//	권장하지 않음
	sprintf(temp, "%x", 10);	//a	//printf할 내용을 전부 문자열에 저장 숫자 10을 16진수(%x)문자로
	puts(temp);	
	
	return 0;
}

 

 

12.1 메모리 레이아웃 훑어보기

-Text Segment : 코드 세그먼트(기계어로 변환된 코드)

-Data Segment : 초기화된 전역,정적변수 쓰기 가능 (여기 저장된 문자열은 Read Only Data Segment에 저장됨)

-BBS Segment : 초기화 되지 않은 전역, 정적 변수

-Heap : 동적 할당

-Stack : 지역변수, 매개변수

- Text Segment: 프로그램 실행 시 프로그램 자체가 메모리에 올라가고 변경 불가능하게 된다

 

-char* str = "Hello, world"; 에서 문자열 Hello, World는 Date Segment중 Read Only Data Segment에 저장됨

따라서 포인터를 통해 str[0] = 'M';은 에러를 일으킨다. 하지만 arr의 경우 stack 메모리를 사용하기 때문에 가능하다

 

- 어떤 변수들은 프로그램 전체에서 계속 사용된다. 이러한 전역 변수는 BBS Segment, Data Segment에 저장된다

 

-지역적으로만 사용할 수 있는 지역변수를 사용하면 메모리 효율이 좋아진다 이러한 지역변수는 스택 메모리에 쌓인다

블록 안이 실행될 때만 stack 메모리를 사용하여 지역변수를 쓰고, 그 외엔 쓰지 않는다

스택 메모리의 특징 중 하나가 지역변수는 컴파일러가 실행 시에 이미 모두 정해진다. 따라서 스택 메모리는 접근이 빠르다. 하지만 필요한 메모리의 크기를 미리 알 수 없을 경우엔 스택 메모리에 담을 수 없다.

 

-이때 사용하는 것이 동적할당 이라고 한다(Heap 메모리 사용) Heap 메모리는 컴파일할 때도 사이즈를 알 수가 없다.

단점은 주소를 배정받을 때 메모리가 얼마나 필요한지 운영체제에 요청하고 받아오는 구조이기 때문에 조금 느리다

또한 Heap의 메모리는 다 쓰꼬 꼭 반납을 해야 하기 때문에 free(arr) 등을 써서, 프로그래머가 메모리를 반납한다.

 

 

12.2 객체(object)와 식별자(identifier), L-value와 R-value

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	/*
		Object
		- "An object is simply a block of memory that can store a value."
		- Object has more developed meaning in C++ and Object Oriented Programing (OOP)

		Identifiers
		- Names for variables, functions, macros, and other entities
	*/

	int var_name = 3;		// ceates an object called 'var_name'

	int* pt = &var_name;	//	pt is an identifier		포인터변수 자체도 주소를 가짐
	*pt = 1;				// *pt is not an identifier. *pt designates an object

	int arr[100];	// arr is an identifier. Is arr an object?
    				// 배열명은 식별자는 맞지만, object는 아니다 - 첫원소에 대한 주소이지 그 자체가 메모르릴 갖지 않는다
	arr[0] = 7;		//	arr[0] is an object

	/*
		Lvalue is an expression 'referring' to an object.

		L-value : left side of an assignment
		R-vlaue : right side, variable, constant, expressions
	*/

	var_name = 3;	//	modifiable lvalue
	int temp = var_name;	// Lvalue가 Rvalue로 사용할 수 있고 이때는 단순히 값을 전달하는 역할

	pt = &var_name;
	int* ptr = arr;
	*pt = 7;	// *pt is not an identifier but an modifiable lvalue expression

	int* ptr2 = arr + 2 * var_name;	// address rvalue
	*(arr + 2 * var_name) = 456;	// lvalue expression

	const char* str = "Constant string";		// str is a modifiable lvalue
	str = "Second string";	// "Constant string" = "Second string"	//	impossible
	//str[0] = 'A';	// Error
	//puts(str);

	char str2[] = "String in an array";
	str2[0] = 'A';	// OK
	//puts(str2);

	return 0;
}

 

 

12.3 변수의 영역(scope)과 연결(Linkage) 상태, 객체의 지속기간(duration)

 

Scope

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

/*
	Variable scopes (visibility)
	- block, function, fuction prototype, file
*/

int g_i = 123;	// global variable
int g_j;

void func1()
{
	g_i++;	// uses g_i
}

void func2()
{
	g_i += 2;
} 

int main()
{
	int local = 1234;

	func1();
	func2();

	printf("%d\n", g_i);// uses g_i
	printf("%d\n", g_j);// Not initialized?	//	0	초기화 되지 않은 전역변수는 컴파일러가 0으로  초기화
	printf("%d\n", local);
	
	return 0;
}

1. block { } : { } 안에 선언된 변수는 { } 안에서만 사용 가능

2. function : 함수 안에서 선언된 변수의 영역은 함수안

3. function prototype : 프로토타입의 경우 프로토 타입 내에서만 visibility. (따라서 자료 형만 쓰고 변수 생략 가능)

4. file scope: 프로그래밍 바깥 부분(ex. 전역변수) - 여기에 있는 변수는 파일 안에서 어디든지 사용

 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

/*
	Variable scopes (visibility)
	- block, function, fuction prototype, file
*/

void f1(int hello, double world);	// to the end of the prototype declaration
//void vla_param(int n, int m, double ar[n][m]);	//	gcc only

double func_block(double d)
{
	double p = 0.0;

	int i;
	for (i = 0; i < 10; i++)
		//for (int i = 0; i < 10; i++)
	{
		double q = d * i;
		p *= q;

		if (i == 5)
			goto hello;
	}
hello:
	printf("Hello, World");

	return p;
}

int main()
{
	func_block(1.0);
}

void f1(int hello, double world)
{
}

 

Linkage

한 프로젝트 안의 두 개의 파일을 Linkage를 통해 서로 변수를 공유할 수 있다.

오른쪽 3번째 줄에 int el;에 extern을 붙이면 '어딘가 선언되어 있는 int el을 써라' 란 의미이다.

반면 왼쪽 15번째 줄에 static int il;은 'int il;을 존재하는 scope 내에서만 존재한다'는 의미이다

 

왼쪽 17번째 줄에서 void testLinkage(); 를 보면 프로토타입을 써서 다른 파일의 함수를 쓸 수 있다.

 

Duration

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

/*
	Storage duration:
	- static storageduration	//	프로그램이 시작될때 메모리를 잡고 끝날때까지 유지
	(Note: 'static' keyword indicates the linkage type, not the storage duration)
	- automatoc storage duration	//	stack에 저장, 지역변수
	- allocated storage duration	//	동적할당
	- thread storage duration		//	멀티쓰레딩
*/

void count()
{
	int ct = 0;	//	현재 block 안에서 끝
	printf("count = %d\n", ct);
	ct++;
}

void static_count()
{
	static int ct = 0;	//	프로그램이 시작될때 메모리를 잡고 끝날때까지 유지
	printf("static count = %d\n", ct);
	ct++;
}

int main()
{
	count();			//	0
	count();			//	0
	static_count();		//	0
	static_count();		//	1

	return 0;
}

 

 

12.4 저장 공간의 다섯 가지 분류

2가지로 분류하기도 한다 (static과 static이 아닌 것)

 

자동변수 : 지역변수 - 지속 기간이 자동적으로 결정

레지스터변수 : CPU 안의 메모리를 쓰는 것으로 엄청 빠름 - 실질적으로 많이 안 쓰인다

Static : 메모리에 고정되어 있다 (컴파일러의 번역단위: 파일)

 

할당메모리 : 런타임에서 운영체제에게 요청해서 '포인터'만 받는다. 즉, 식별자가 없다

 

 

12.5 자동변수 Automatic Variables

19번째 줄에서 스택에 int b = 123 이 쌓였다가

21번째 줄에서 scope를 빠져나오며 스택에서 빠지는 것을 확인할 수 있다.

 

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

/*
	Automatic storage class
	- Automatic storage duration, block scope, no linkage
	- Any variable declared in a block or function header
*/

void func(int k);

int main()	//Note: main() is a function.
{
	auto int a;	// keyword auto : a storage-class specifier
	a = 1024;
	//printf("%d\n", a);		// whaat happens if uninitialized?
	//auto int b = a * 3;		// whaat happens if uninitialized?
	// bss 에 있는 변수들은 컴파일러가 알아서 0으로 초기화 시켜주지만, 
	// 자동변수는 스택에 생성될때마다 초기화해주면 "비용"이 발생하므로 별도로 초기화 안시켜줌
	// 따라서 "자동변수는 반드시 초기화 시켜줘야함"(c++ 에서는 이런 불편함을 덜느끼도록 여러가지 장치가 되있다고함
	
	int i = 1;
	int j = 2;

	printf("i %lld\n", (long long)&i);

	{
		int i = 3;	//name hiding
		printf("i %lld", (long long)&i);

		int ii = 123;

		// j is visible here
		printf("j = %d\n", j);
	}

	// ii is not visible here

	printf("i %lld\n", (long long)&i);	// which i?

	for (int m = 1; m < 2; m++)
		printf("m %lld\n", (long long)&m);		// no block?

	func(5);	// cannot see any of the variabled defined so far

	for (int m = 3; m < 4; m++)
	{
		printf("m%lld\n", (long long)&m);		// block?
	}

	return 0;
}

void func(int k)// stack frame 이 바껴서 main함수에서 쓰던 변수들에 접근할 수 없다
{
	int i = k + 2;
	// do something with i and k
	printf("i %lld\n", (long long)&i);
}