C++ 배열, 2차원배열, 문자열배열, 3차원 배열

#include <iostream>

using namespace std;

void main()
{
//// 배열
//// 동일한 특성(같은 자료형)을 가지며, 일정한 규칙(연속된 메모리)에따라 나열되어 있는 데이터 집합!
//// -> 변수를 여러개 선언할 경우 쉽게 선언할 수 있다!

//// 배열의 형태
///*
//자료형  변수명[ 배열 수 ]
//*/
//int iArr[5];

//cout << sizeof(int) << endl;
//cout << sizeof(iArr) << endl;


//// 배열의 초기화
//// 배열은 중괄호를 이용하여 값을 초기화한다!!!

//// 5개의 변수가 모두 쓰레기 값으로 초기화된다.
//int iArr[5];

//// 5개의 변수가 모두 0으로 초기화된다.
//int iArr[5] = {};

//// 5개의 변수가 순차적으로 초기화가 진행 된다.
//// -> 앞에서부터 1, 2, 3, 4, 5로 채워진다.
//int iArr[5] = { 1, 2, 3, 4, 5 };

//// 앞에서부터 순차적으로 채워지고 나머지 변수들은 0으로 채워진다.
//// -> 1, 2, 3, 0, 0
//int iArr[5] = { 1, 2, 3 };



// 배열의 원소 접근(인덱스 접근)
// [] : 인덱스 접근 연산자
// [] 안에 접근하고자 하는 인덱스를 넣어주면 된다.
// 단, 인덱스는 0부터 시작한다.

// 선언 시 사용한 []는 배열의 크기를 명시하는 것이다!
// 선언 후 사용한 []는 인덱스 접근을 의미하는 것이다!


//int iArr[5] = { 1, 2, 3, 4, 5 };
////cout << iArr[2] << endl;

////cout << iArr[0] << endl;
////cout << iArr[1] << endl;
////cout << iArr[2] << endl;
////cout << iArr[3] << endl;
////cout << iArr[4] << endl;

//for (int i = 0; i < 5; ++i)
// cout << iArr[i] << endl;


//// 배열의 크기로 변수를 설정하자!
//// 함수가 시작되면 stack 영역을 할당한다!
//// 과연? stack 영역은 얼마만큼 크기로 할당하는가?
//// -> stack 의 크기는 지역 변수가 몇개냐에 따라 stack의 크기가 계산된다.

//// 배열의 크기로 변수를 지정할 경우 크기가 바뀔 가능성이 있다!
//// -> stack의 크기를 계산할 수 없다!
//int iSize = 0;
//cin >> iSize;

//int iArr[iSize]; // 불가능

////// 정적 배열
////// 컴파일 시점에 배열의 크기를 알아야 하고, 런타임 시점에 크기가 바뀌면 안된다!!!!
////// 이로 인해, 정적 배열은 크기로 상수 값을 받는다!!!

//int iArr1[5];

//const int iSize = 5;
//int iArr2[iSize];


// 일정한 규칙
int iArr[5] = {};

cout << iArr << endl;
cout << "--------------------------------" << endl;
for (int i = 0; i < 5; ++i)
cout << &iArr[i] << endl;



}

 

#include <iostream>

using namespace std;

void Func(int* _iArr, int _iSize);
void main()
{
// 배열과 포인터
// 배열의 이름을 출력하면 배열이 할당된 메모리의 시작 주소가 반환된다.
// 이는 포인터와 연관이 있다!
// 포인터에 배열의 시작 주소를 저장해보자!!

//// 배열의 이름은 포인터 변수이다!
//int iArr[5] = { 1, 2, 3, 4, 5 };
//int* ptr = iArr;

//cout << *ptr << endl;

//int iArr[5] = { 1, 2, 3, 4, 5 };
//int iA = 10;
//int* ptr = &iA;

//// 배열의 이름은 포인터이다!
//// 만약, 다른 주소를 대입 받을 수 있을 경우
//// 배열이 할당된 공간을 잃어버리게 된다!!
//// 공간을 잃어버리면 다시 배열에 접근할 수 없게 되는 문제가 발생한다!
//// -> 배열의 이름은 포인터이지만 상수 포인터이다!!
//iArr = &iA; // 불가능


//// 포인터 연산
//// 주소를 대상으로 더하기, 빼기를 수행한다.
//
//int iArr[5] = { 1, 2, 3, 4, 5 };
//int* ptr = iArr;

//cout << ptr << endl;

//// 시작 주소부터 1byte만큼 증가한 것이 아니라 4bytes만큼 증가한 값이 나온다.
//// 만약, 1byte만큼 증가할 경우 역참조 연산자를 사용하면 엉뚱한 값이 나오게 된다.
//// 엉뚱한 값은 사용자가 저장한 값이 아니기 때문에 아무런 의미가 없게 된다.
//// 그래서 포인터 연산을 수행하면 자료형의 크기만큼 증가한 주소가 나오게 된다.
//cout << (ptr + 1) << endl;


//int iArr[5] = { 1, 2, 3, 4, 5 };
//int* ptr = iArr;

//// 인덱스 접근 연산자는 + x한 주소 값에 역참조 연산자를 사용해라 라는 말과 같은 말이 된다.
//cout << *(ptr + 0) << endl; // cout << iArr[0] << endl;
//cout << *(ptr + 1) << endl; // cout << iArr[1] << endl;
//cout << *(ptr + 2) << endl; // cout << iArr[2] << endl;
//cout << *(ptr + 3) << endl; // cout << iArr[3] << endl;
//cout << *(ptr + 4) << endl; // cout << iArr[4] << endl;



// 함수의 인자로 배열을 전달하는 방법
// 매개 변수에 사용한 int _ptr[] 는 int* ptr과 다를 것이 없다!
// 단순히 주소를 받겠다는 의미이다!
// 단, int _ptr[]는 배열을 받기 위해 명시적으로 사용하는 문법이다!
int iArr[5] = { 1, 2, 3, 4, 5 };
Func(iArr, sizeof(iArr) / sizeof(int));
}

//void Func(int* _ptr, int _iSize)
void Func(int _ptr[], int _iSize)
{
for (int i = 0; i < _iSize; ++i)
{
cout << _ptr[i] << endl;
}
}

 

#include <iostream>

using namespace std;

void main()
{
//// 2차원 배열
//// 2차원 배열은 변수 선언 시 []를 2개 사용한다.
///*
//자료형  변수명[ 행 ][ 열 ]
//*/
//// 쉽게 이해하는 방법은 뒤에부터 읽으면 된다.
//// -> 3개 짜리가 2개 있다!
///*
//ㅁㅁㅁ,
//ㅁㅁㅁ
//*/
//int iArr[2][3];


//// 2차원 배열의 초기화
//// 1차원과 비슷한 형태를 가진다.
//int iArr[2][3] = 
//{
// { 1, 2, 3 },
// { 4, 5, 6 }
//};

//for (int i = 0; i < 2; ++i)
//{
// for (int j = 0; j < 3; ++j)
// cout << iArr[i][j] << endl;
//}

////for (int i = 0; i < 3; ++i)
//// cout << iArr[0][i] << endl;

////for (int i = 0; i < 3; ++i)
//// cout << iArr[1][i] << endl;

////cout << iArr[0][0] << endl;
////cout << iArr[0][1] << endl;
////cout << iArr[0][2] << endl;

////cout << iArr[1][0] << endl;
////cout << iArr[1][1] << endl;
////cout << iArr[1][2] << endl;



////// 2차원 배열의 원소
////// 2차원 배열의 원소는 1차원 배열이다!!!
////int iArr[5] = { 1, 2, 3, 4, 5 };
////cout << *iArr << endl;
////cout << iArr + 1 << endl;

//int iArr[2][3] = { 1, 2, 3, 4, 5, 6 };
//cout << "(iArr + 0): " << (iArr + 0) << endl;
//cout << "*(iArr + 0): " << *(iArr + 0) << endl;
//cout << "**(iArr + 0): " << **(iArr + 0) << endl; // 1

//// 다음 원소의 주소를 확인해라!!
//// 첫 번째 원소(1차원 배열)의 크기만큼 증가한 값을 가진다!
//cout << "(iArr + 1): " << (iArr + 1) << endl;
//cout << "*(iArr + 1): " << *(iArr + 1) << endl;
//cout << "**(iArr + 1): " << **(iArr + 1) << endl; // 4


// 2차원 배열의 포인터형
int iArr[2][3] = { 1, 2, 3, 4, 5, 6 };

// 포인터 연산의 증가 값이 다르기 때문에 불가능하다.
// ptr + 1은 4bytes(int*)만큼 증가한다.
// iArr + 1 은 12bytes(int형 3개 배열)만큼 증가한다.
//int** ptr = iArr;

/*
자료형(*변수명)[열]
*/
int(*ptr)[3] = iArr;

}

#include <iostream>

using namespace std;

void main()
{
// 3차원 배열
int iArr[2][3][4] = 
{
{
{ 11, 12, 13, 14 },
{ 15, 16, 17, 18 },
{ 19, 20, 21, 22 }
},
{
{ 23, 24, 25, 26 },
{ 27, 28, 29, 30 },
{ 31, 32, 33, 34 }
}
};
}

 

#include <iostream>

using namespace std;

void main()
{
// 문자 배열
// 문자열 상수


////// 문자 배열
////// 배열을 선언할 때 자료형을 char로 만들면 문자 배열이 된다.
////char szBuff[30];

//// 문자 배열의 초기화
//// 초기화는 선언과 동시에 문자열을 대입해주면 된다.

//// char 크기의 공간을 30개 만들고 앞에서부터 순차적으로
//// 문자열의 문자를 하나씩 대입해준다.
//// 문자를 대입한 후 다음공간에는 NULL문자를 자동으로 추가한다.
//char szBuff[30] = "Hello";

//// cout은 내부적으로 printf를 호출한다!
//// int형을 출력하라 말하면 정수형을 출력해준다.
//// int*형을 출력하라 말하면 주소를 출력해준다.
//// 단, char*를 출력하라 말하면 주소가 아닌 주소에 있ㄴ는 문자들을 출력해준다.
//cout << szBuff;



//// 문자 배열의 원소 접근
//// 배열 원소에 접근하는 것처럼 사용할 수 있다.
//// -> 읽기/쓰기 가능하다!
//char szBuff[10] = "Hello";

////cout << szBuff[2] << endl;
//szBuff[2] = 'L';

//cout << szBuff << endl;


//// NULL 문자를 사용자가 임의로 변경하면
//// 어딘가에 있을 NULL문자를 만날 때까지 데이터를 계속해서 읽어나간다.
//// -> 배열의 크기를 설정할 때 NULL문자를 포함한 크기로 설정하자!!
//char szBuff[6] = "Hello";
//szBuff[5] = 'A';
//cout << szBuff << endl;


// 문자 배열의 값 변경
// 문자 배열은 선언과 동시에 초기화를 진행해야만 한다!!!!
char szDst[10] = "Hello";
char szSrc[10] = "World";

//// 배열의 이름은 주소이다.
//// 주소에 주소를 대입하고 있는 형태이다.
//// 하지만, 배열의 이름은 상수 포인터이므로 대입을 받을 수 없다!!
//szDst = szSrc; // 불가능
szDst = "World";


}

 

#include <iostream>

using namespace std;

void main()
{
int iArr[25] = {};

for (int i = 0; i < ? ; ++i)
{
for (int j = 0; j < ? ; ++j)
cout << iArr[? ] << '\t';
cout << endl;
}

/*
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
*/
}