728x90

배열(array)

- 주소값을 가지고 포인터 연산을 통해 배열의 모든 연소에 각각 접근할 수 있음

- 배열 선언 시, 메모리에 같은 크기의 공간들을 연속적으로 할당해놓고,

-->첫번째 요소의 주소값을 가지고 정수 연산

-->이어진 다음 요소의 주소를 계산할 수 있음

-->주소에 *를 붙여서 각 요소에 직접 전근 가능

 

예시1

int ary[5] = {1, 2, 3, 4, 5}

cout << art ; //4390184 첫 번째 원소의 주소 반환

cout << art+1 ; //4390188 두 번째 원소의 주소 반환(+4)

파이썬에서 그 배열이 아니다~~~!~!

c++에서 배열은 그 배열 첫번째 원소의 주소값을 반환한다!

 

이때, 'cout << 배열'을 하면, 해당 배열의 첫번째 원소 주소값이 저장되어있긴 하지만,

cout을 만났을 때 '얘는 배열이므로, 저장되어 있는 첫번째 원소의 주소값부터 null의 주소값까지의 value(chars)를 출력해주자

 

로 해석한다.

 

예시2

int* p = ary+1 // 포인터 p에 4390188 입력했다는 것.

이때, p - ary는 4가 아니라 1임. p와 ary 둘 다 '주소'이기 때문에 주소 연산을 수행함.

포인터+정수 → 포인터+(정수 x sizeof포인터)

 

 

pointer & new를 통해 동적 자료 만들기.

 

1.

#include <iostream>
#define SIZE 20
int main(){
    using namespace std;

    double* p3 = new double[3]; //double형 데이터 3개를 저장할 수 있는 공간을 대입
    p3[0] = 0.2; //p3를 배열 이름처럼 취급
    p3[1] = 0.5;
    p3[2] = 0.8;
    //new 연산자를 통해 동적 배열을 생성
    //pointer를 사용하여, 해당 배열의 원소에 개별적으로 접근 가능

    p3 = p3 + 1; //배열에 값을 더하는 행위//double의 크기만큼 더해짐

    cout << p3 <<endl; //0x6000022e1188
    cout << "Now p3[0] is " << p3[0] << " and "; //Now p3[0] is 0.5 //기존 p3[1]의 값
    cout << "p3[1] is " << p3[1] << ".\n"; // p3[1] is 0.8.

    p3 = p3 -1;
    delete[] p3;
    /**/

    char animal[SIZE];
    //char로 문자열을 지정할 때는, 문자열 크기를 미리 선언해야 함
    //컴파일 시간에 배열의 크기를 결정하는 것
    char* ps;

    cout << "동물 이름을 입력하십시오\n";
    cin >> animal;

    ps = new char[strlen(animal)+1]; //사용자가 무슨 animal을 입력하든 그보다 한 칸 더 넉넉히.
    //실행 시간에 배열의 크기를 결정하는 것이, 메모리 차원에서 훨씬 유리함

    strcpy(ps, animal); //animal의 값을 ps에 복사

    cout << "입력하신 동물 이름을 복사하였습니다" << endl;

    cout << "입력하신 동물 이름은 " << animal << "이고, 주소는 " << (int*)animal << "인데," << endl;
            //입력하신 동물 이름은 panda이고, 주소는 0x16f9235e4인데,
    cout << "그것을 복사한 것의 이름은 " << ps << "이고, 주소는 " << &ps << "일까, " << (int*)ps <<"일까?";
            //그것을 복사한 것의 이름은 panda이고, 주소는 0x16f9235d0일까, 0x600000b48030일까?
            //복사된 값이 원래 주소와 다름
}

2.

#include <iostream>
#define SIZE 20

/**/
//동적(dynamic): 컴파일 시간이 아닌, 실행 시간에 size를 받음
//동적 구조체 생성
//temp* ps = new temp;

struct MyStruct{
    char name[20];
    int age;
};

int main() {
    using namespace std;
    MyStruct* temp = new MyStruct; //new 연산자를 통해, 구조체를 동적으로 생성
    cout << "당신의 이름: ";
    cin >> temp->name; //화살표 멤버 연산자

    cout << "당신의 나이: ";
    cin >> (*temp).age; // 화살표 대신, (*구조체 변수). 도 가능

    cout << "안녕하세요! " << (*temp).name << "씨!\n";
    cout << "당신은 " << temp->age << "살 이군요!";

    cout << temp <<endl; //0x600000289180
    cout << (int*)temp << endl; //0x600000a5d180
    cout << &temp << endl; //0x16b0d75f8
//    cout << temp[0] << endl;
    cout << temp->name << endl; //fish
    // char 배열이므로 저장된 건 첫번째 요소의 주소값이지만 cout을 통해 해당 주소값부터 null이 있는 주소값까지의 char들을 출력
    cout << *(temp->name) << endl; //name에 영단어를 입력하면 첫번째 알파벳 f가 나옴(한글은 ?로 뜸)
    cout << &(temp->name) << endl; //0x600000289180
    
    /*번외*/
    cout << (int*)(temp->name) << endl; //0x600000289180
    // !=(int)(*변수) : 변수가 참조하는 대상을 int로 typecast한 결과

}

→ 여기서도 temp 구조체 포인터 안에 저장된 name은 배열이므로, 해당 배열 첫번째 원소의 주소값이 저장되어 있다.

따라서,

- temp->name: 해당 주소값~null의 주소값 범위에 해당하는 chars를 문자열로 출력해주고 : fish

- *(temp->name): 해당 배열 첫번째 원소의 주소값이 가리키는 char를 출력해주고 : f

- &(temp->name): 해당 배열 첫번째 원소의 주소값의 주소값을 출력해주고 : 0x6000~

 

- (int*)(temp->name): 얘는 아직 잘 모르겠다,, ㅎㅎ (int*)pointer는 pointer의 값 자체를 주소값으로 선언해준다는 건 읽었는데, 위 결과와 매칭을 잘 못 시키겠음...

"pointer를 이용하여 출력된 값은 정수 값이고 (int *)pointer를 이용해서 나오는 값은 번지 값이다"
출처:https://sunder4.tistory.com/150

728x90
728x90

c++은 객체지향 프로그래밍

- 컴파일 시간이 아닌 '실행 시간'에 어떠한 '결정'을 내릴 수 있다.

 

e.g.) 배열을 생성할 때,

재래적 절자척 프로그래밍: 배열의 크기를 미리 결정해야 함

객체지향 프로그래밍: 배열의 크기를 실행 시간에 결정할 수 있음-> 값이 변할 수 있는 변수배열의 크기를 결정할 수 있음

 

일주일에 한 번만 200개의 공간이 필요하다면, 재래적 절차적 프로그래밍의 경우 남은 6일 간 180이 낭비됨

객체지향 프로그래밍에서는, 20을 유지하다가, 필요에 따라 간헐적으로 200으로 늘림


포인터

변수 선언 과정에서, 변수의 이름을 통해 변수를 관리하는 것이 아니라, 저장할 데이터를 다루는 '주소'이름을 붙임

즉, 포인터는 포인터의 이름 자체주소를 나타냄.

이를 간접값 연산자, 간접 참조 연산자 * 로 나타냄

 

1-1. 포인터 선언, 변수와 연결

#include <iostream>

using namespace std;

int main(){

    int val = 3;
    cout << &val << endl; //val이라는 변수가 저장된 메모리 주소 : 0x16b0135fc

    /*포인터 선언하기*/
    //포인터는 개념적으로 정수와 다른 개념 (수가 아닌 위치를 나타냄)
    //포인터에는 어떤 정수를 대입하는 것이 아무런 의미가 없음
    //대신, 포인터에 어떠한 변수의 주소를 대입함으로써,
    // 포인터를 이용하여 해당 주소의 값에 직접 변화를 줄 수 있음

    int *a; // c style
    int* b; // c++ style
    int* c,d; //c는 포인터 변수, d는 int형 변수로 선언됨
	
    /*e의 주소 저장을 위해 f가 선언됨*/
    int e = 6;
    int* f; //그 자체로 주소를 나타냄

    f = &e; //포인터 f와 변수 e가 연결됨 -> f가 바뀌면 e도 연동되어 바뀜
    //위 코드는 *f = e;로 대체할 수 없음(error)

    cout << "e의 값 " << e << endl; //e의 값 6
    cout << "*f의 값 " << *f << endl; //*f의 값 6
    cout << "e의 주소 " << &e << endl; //e의 주소 0x16fcf75d8
    cout << "*f의 주소 " << &*f << endl; //*f의 주소 0x16fcf75d8
    cout << f << endl; //0x16f7e35d8

    *f = *f + 1; //주소에 해당하는 값에 직접 변화 주기
    cout << "이제 e의 값은 " << e << endl; //이제 e의 값은 7
    cout << *f << endl; // 0x16d2ef5d8 -> 값이 저장된 주소는 바뀌지 않음

}

- 즉, 포인터는 특정 데이터의 '주소'저장을 위한 용도로 생성됨.

 

1-2. new를 통해 포인터 선언 및 초기화

#include <iostream>

using namespace std;

int main(){

    /*이전시간에 활용한 방법: 주소에 접근할 때 a와 b 둘을 통해 모두 접근 가능*/
    int a;
    int* b = &a;

    //new 연산자
    /*
     * 어떤 데이터형을 원하는지 new 연산자에 알려주면,
     * new 연산자는 '그'에 알맞은 크기의 메모리 블록을 찾아내고
     * 그 블록의 '주소'를 리턴함*/

    int* pointer = new int; //int형을 위한 새로운 메모리가 필요함을 알려줌
    //new는 int임을 확인하여 몇 바이트가 필요한지 계산(e.g. 4btyes)
    //해당 바이트를 저장할 수 있는 메모리 블록을 찾아 해당 주소를 반환
    
 
}

1-3. 배열 형식의 포인터 선언 및 초기화

#include <iostream>

using namespace std;

int main(){
    
    double* p3 = new double[3]; //double형 데이터 3개를 저장할 수 있는 공간을 대입
    p3[0] = 0.2; //p3를 배열 이름처럼 취급
    p3[1] = 0.5;
    p3[2] = 0.8;

    cout << "p3[1] is " << p3[1] << ".\n"; //p3[1] is 0.5.

    p3 = p3 + 1; //배열에 값을 더하는 행위
    //원래 배열 이름은 값을 변경할 수 없음.
    //그러나 포인터는 변수처럼 사용할 수 있어서, 값 변경 가능.
    /* double 데이터 3개를 저장하는 공간이므로,
     p3에 1을 더한다는 것 =뒤에 있던 double형 데이터 공간 1개를 앞당기는 것
     p3[0] -> 0.5를 point
     p3[1] -> 0.8을 point
     */

    cout << "Now p3[0] is " << p3[0] << " and "; //Now p3[0] is 0.5 //기존 p3[1]의 값
    cout << "p3[1] is " << p3[1] << ".\n"; // p3[1] is 0.8.


}

 

 

2. 포인터를 delete

- delete 연산: 사용한 메모리를 다시 메모리 풀의 영역으로 환수 => 환수된 메모리는 프로그램의 다른 부분이 다수 사용할 수 있음
- delete ps; //new를 사용한 다음에는 반드시 delete를 사용해야 함
- delete 없으면 ; 대입은 되었지만 사용되지 않는 메모리 누수 발생 -> 프로그램 먹통

#include <iostream>

using namespace std;

int main(){

    /*delete 연산: 사용한 메모리를 다시 메모리 풀의 영역으로 환수*/
    //환수된 메모리는 프로그램의 다른 부분이 다수 사용할 수 있음

    int* ps = new int;
    //포인터변수 ps를 선언, 메모리 사용
    delete ps; //new를 사용한 다음에는 반드시 delete를 사용해야 함
    //delete 없으면 ; 대입은 되었지만 사용되지 않는 메모리 누수 발생 -> 프로그램 먹통

    /*delete를 사용하는 네 가지 규칙*/
    //1. new로 대입하지 않은 메모리는 delete로 해제할 수 없음
    //2. 같은 메모리 블록을 연달아 두 번 연속 delete로 해제할 수 없음 (한번으로 충분)
    //3. new[]와 같이 대괄호 형식 메모리 대입할 시, delete 역시 delete[]로 해제
    //4. 대괄호를 사용하지 않았다면, delete

    double* p3 = new double[3]; //double형 데이터 3개를 저장할 수 있는 공간을 대입
    p3[0] = 0.2; //p3를 배열 이름처럼 취급
    p3[1] = 0.5;
    p3[2] = 0.8;

    cout << "p3[1] is " << p3[1] << ".\n"; //p3[1] is 0.5.

    p3 = p3 + 1; //배열에 값을 더하는 행위
    //원래 배열 이름은 값을 변경할 수 없음.
    //그러나 포인터는 변수처럼 사용할 수 있어서, 값 변경 가능.
    /* double 데이터 3개를 저장하는 공간이므로,
     p3에 1을 더한다는 것 =뒤에 있던 double형 데이터 공간 1개를 앞당기는 것
     p3[0] -> 0.5를 point
     p3[1] -> 0.8을 point
     */

    cout << "Now p3[0] is " << p3[0] << " and "; //Now p3[0] is 0.5 //기존 p3[1]의 값
    cout << "p3[1] is " << p3[1] << ".\n"; // p3[1] is 0.8.

    p3 = p3 -1;
    delete[] p3;
}

reference: https://inf.run/4ttD

728x90
728x90

1. 배열과 문자열

#include <iostream>

using namespace std;

int main(){
//c++는 복합데이터형을 제공 : 사용자 정의대로 새로운 데이터형을 만들 수 있음
//복합데이터형 : 기본 정수형과 부동소수점형의 조합
//ex) 배열(array) : 같은 데이터형의 집합

/*배열(array)
 * typeName arrayName[arraySize]

 * 배열 초기화를 선언 이후 나중에 할 수 없음, 배열을 다른 배열에 통째로 대입할 수 없음
 * short month[5] = { ... };
 * short year[12] = { ... };
 * year = month; 불가능함
 * 초기화 값의 개수를 배열 원소의 개수보다 모자라게 제공할 수 있음
 * 배열을 부분적으로 초기화하면 나머지 원소는 모두 0으로 설정
 * 명시적으로 첫 번째 원소만 0으로 초기화하면, 나머지 원소들은 모두 0으로 초기화됨
 * 배열 사이즈를 명시하지 않으면 초기화 시의 원소 개수로 배정됨
 * */

short month[12]; //새로운 배열 선언 //month 배열의 원소는 최대 12개, 모두 short형
short month2[12] = {1, 2, 3};

cout << month2[0] << endl; //인덱스 통해 원소 출력

/*
 * 문자열: 문자의 열
 * char 리스트와 쌍따옴표로 문자열(스트링) 표현 가능
 * */

char a[5] = {'H', 'e', 'l', 'l', 'o'};
//이보다 더 효율적으로 문자열 정의하는 방법
char b[] = "Hello"; //쌍따옴표는 명시적으로 null문자를 포함하므로 스트링 표현 가능

cout << b;

}

2-1. 사용자 입력(cin)

#include <iostream>
#include <cstring>

using namespace std;

int main(){
    //<cstring>의 헤더 파일에 포함되어 있는 <strlen> : 문자열의 길이를 반환하는 함수
    //<sizeof> : 변수의 크기를 반환하는 함수
    const int Size = 15;
    char name1[Size];
    char name2[Size] = "C++programming";

    cout << "안녕 나는" <<name2;
    cout << "이야~\n";
    // cin >> name1; //사용자의 입력을 오른쪽 변수에 저장 //input느낌
    //문제는 화이트스페이스를 반영하지 못하고 그 전으로 자름
    /*이를 해결하는 것이 get & getline*/
    cin.getline(name1, Size); //(변수, 크기) //get도 마찬가지

    cout << "음 " << name1 << "씨, 당신의 이름은 ";
    cout << strlen(name1) << "자입니다만\n";
    cout << sizeof(name1) << "바이트 크기에 저장되었습니다.\n";
    cout << "이름이" << name1[0] << "자로 시작하시는군요.\n";
    name2[3] = '\0'; //문자열 출력 시 null 문자까지만 출력함
    cout << "제 이름의 세 문자는" << name2 << "입니다.";

}

2-2. string

#include <iostream>

using namespace std;

int main(){

    //c++에서 문자열을 다루는 방법 중 하나인 'string'
    /*
     * c스타일로 string 객체를 초기화할 수 있음
     * cin을 사용하여 string 객체에 키보드 입력을 저장
     * cout을 사용하여 string 객체를 보여줌
     * 배열 표기를 사용하여 string객체에 저장된 개별 문자에 접근 가능
     * => 문자열과 속성이 비슷한데,
     * => string을 통해서는 배열을 다른 배열에 통째로 대입할 수 있음 
     * => 배열 크기를 미리 지정하지 않아도 됨 */

    char char1[20];
    char char2[20] = "jauar";
    string str1;
    string str2 = "panda";
    // char1 = char2; //값이 들어가지 않음
    str1 = str2; //제대로 대입 됨
    cout << str1;

}

3. 구조체(struct)

#include <iostream>

using namespace std;

int main(){

    //c++만의 특장점: 사용자의 정의 및 입력대로 원하는 데이터를 만들 수 있음
    /*정말 중요한 '구조체'  (복합데이터형 중 하나)*/
    //배열: 같은 데이터형의 집합
    //구조체: '다른 데이터형이 허용되는' 데이터의 집합

    //축구선수
    struct MyStruct {
        string name;
        string position;
        int height;
        int weight;
    };

    MyStruct A; //A라는 이름의 MyStruct형의 데이터를 만든 것 //약간 class느낌..?
    A.name = "Son";
    A.position = "Striker";
    A.height = 183;
    A.weight = 77;

    MyStruct B = {
            "Min", "defender", 160, 49
    };

    cout << B.weight << endl;

    //구조체 생성 시 중괄호 뒤에 생성할 구조체명을 선언하면
    //실제 선언 시 구조체 형식을 전부 명시하지 않아도 됨

    //또한, 구조체에 포함된 모든 변수를 선언하지 않아도 됨, 자동으로 0이 됨

    struct Ming {
        string firstname;
        string lastname;
    } minji;

    minji.firstname = "minji";
    minji.lastname = "Jo";

    cout << minji.firstname << endl;

    //배열을 선언하듯 구조체를 선언할 수 도 있음
    Ming minfamily[2] = {
            {"jungah", "Han"}, //첫번째 인덱스에 해당하는 정보
            {"seokhyeon", "Jo"} //두번째 인덱스에 해당하는 정보
    };

    cout << minfamily[0].lastname;

}

4. 공용체 (union)

#include <iostream>

using namespace std;

int main(){

    //c++에서 지원하는 복합데이터형 중 : 공용체 & 열거체
    /*공용체(union): 서로 다른 데이터형을 한 번에 한 가지만 보관할 수 있음 */

    union MyUnion{
        int intVal;
        long longVal;
        float floatVal;
    };

    MyUnion test;
    test.intVal = 3;
    test.longVal = 33;
    test.floatVal = 3.3;

    cout << test.intVal << "\n" << test.longVal << "\n" << test.floatVal << endl;
    //1079194419
    //1079194419
    //3.3
    //여러 데이터형을 사용할 수 있지만, 동시에 사용은 불가능
    // -> 메모리 절약 가능 (운체, 하드웨어 등에 주로 활용됨)


}

5. 열거체(enum)

#include <iostream>

using namespace std;

int main(){

    //c++에서 지원하는 복합데이터형 중 : 공용체 & 열거체

    /*열거체(enum): 기호 상수(한번 선언된 이후 변경 불가)를 만드는 또다른 방법*/
    enum spectrum {red, orange, yellow, green=5};
    //1. spectrum을 새로운 데이터형 이름으로 만듦
    //2. red, orange, yellow, green의 열거자를 다양한 수를 0~3까지 정수 값을 각각 나타내는 기호 상수로 만듦
    //-> 즉 문자로 정수를 사용하게 됨
    //-> 사용된 열거자를 상수로 관리함
    // 명시적으로 정수 값을 직접 대입할 수 있음 (자동배정되는 값을 사용하지 않으려면.)
    spectrum a = orange; //열거체 생성 시, 열거자만 대입할 수 있음
    //열거자끼리 직접 산술연산 불가능 (orange+yellow//error)

    int b;
    b = green; //열거자를 int 변수에 대입하면 산술연산 사용 가능
    b = green + 3;


    cout << b << endl;

}

 

reference: https://inf.run/4ttD

728x90
728x90

1. 변수 선언과 규칙

#include <iostream>

using namespace std;

int main(){
    //1. 변수

    /*
     1. 변수의 자료형
     2. 변수의 이름
     3. 변수가 어디에 저장되는가?(메모리 영역) - 컴파일러가 직접 결정해줌
     -> 주소값 알려면 변수 앞에 &붙이면 됨
     */
    int a; //int라는 자료형의 a라는 변수명
    a = 7; //int라는 자료형 명시했으므로 가능
    /*
     * 변수명의 규칙
     1. 숫자로 시작할 수 없음
     2. c++에서 사용하고 있는 키워드는 사용할 수 없음
     3. white space(space/tab/enter)를 사용할 수 없음
     */
    { int b;
        {
            //int a; 하단 블록에서 정의되면, 상단에서 사용될 수 없음
            b=3; //상단 블록에서 정의되었으므로 가능
        }
        //a=5;
    }

    int b = 3; //초기화 : 선언하자마자 대입

    cout << a << b; //73

    //변수는 사용되기 이전에 정의되어야 함

    return 0;
}

 

2. 정수형 자료형과 실수형 자료형

#include <iostream>
#include <climits>
using namespace std;

int main(){
    /*
     * 정수형: 소수부가 없는 수 -> 음의 정수, 0, 양의 정수
     * */
    //short, int, long, long long
    //메모리가 한정되어 있는데, 정수 크기와 정수 개수의 스펙트럼이 넓다 보니
    //이를 효율적으로 활용하기 위해 정수형을 네 가지의 types로 나누었음

    int n_int = INT_MAX; //이는 <climits>에서 정의된 int의 max값에 대한 '상수'
    short n_short = SHRT_MAX;
    long n_long = LONG_MAX;
    long long n_longlong = LLONG_MAX;

    cout << "int는 " << sizeof n_int << "바이트이다." <<endl; //4바이트
    cout << "이 바이트의 최대값은 " << n_int << " 이다." <<endl;

    cout << "short는" << sizeof n_short << "바이트이다." <<endl; //2바이트
    cout << "이 바이트의 최대값은" << n_short << " 이다." <<endl;
    //short 자료형은 음의 정수를 표현할 수 있음 : ~32768 ~ 32767

    cout << "long은" << sizeof n_long << "바이트이다." <<endl; //4바이트
    cout << "이 바이트의 최대값은" << n_long << " 이다." <<endl;

    cout << "long long은" << sizeof n_longlong << "바이트이다." <<endl; //8바이트
    cout << "이 바이트의 최대값은" << n_longlong << " 이다." <<endl;

    unsigned short b;
    //음의 정수형을 사용하지 않을 예정이므로, 범위를 0~655535까지 넓힐 수 있음
    b = -1;
    cout << b << endl; //65535


    /*
     * 실수형: 소수부를 저장할 수 있음
     */
    float a = 3.14; //3.14
    int c = 3.14; //3

    cout << a << endl << c << endl;

 

3. char형과 bool형

#include <iostream>

using namespace std;

int main(){
    //char: 작은 문자형-아스키코드 // 아스키코드로 표현할 수 있는 문자 내에서만
    int a = 77;
    char b = a; //M
    char c = 'a'; //a
    cout << b << c << endl;

    //큰따옴표로 표현되는 문자열은 char형로 사용될 수 없음!!!
    //c++에서 문자 출력하고자 할 때, 문자를 정수로 저장하는데,
        //이를 위해 어디까지가 문자인지 알아야 함
    //한 개의 문자가 아닌 긴 문자열을 출력하고자 할 때는, 어디까지가 문자인지 표시하는 null 문자(\0)가 필요함
        //큰 따옴표는 명시적으로 null 문자가 표현된 것 -> string 자료형을 위해 사용

    char d[] = {'a', 'b', 'c'};
    cout << d << endl; //abc�aMM //우연치않게 null을 만날 때 까지 출력을 반복

    char e[] = {'a', 'b', 'c', '\0'};
    cout << e << endl; //abc

    //char f = "a" //'a'와 null 문자를 함께 저장한 건데, char은 한 개의 문자만 포함해야 하므로, 오류 발생

    //한글은 char-아스키코드에서 지원해주지 않음, 유니코드로만 표현됨
        //c-wput, location, string형 사용 등

    /*
     * bool 타입: 숫자를 0 혹은 1로만 저장, 0이외 모든 수는 1로 저장됨
     * */

    bool g = 0; //0
    bool h = 1; //1
    bool i = 10; //1

    cout << g << endl << h << endl << i << endl;


}

3. 상수형과 자료형변환

int main(){

    /*상수: 바뀔 필요가 없거나, 바뀌어서는 안 되는 수 -> 변수형까지 선언해야 함*/
    const float PIE = 3.1415926;
    int r = 3;
    float s3 = r*r*PIE;

    cout << s3; //28.2743

    /*데이터형 변환
    1. 특정 데이터형의 변수에 다른 데이터형 값을 대입했을 때
     2. 수식에 데이터형을 혼합하여 사용했을 때
     3. 함수에 매개변수를 전달할 때
     */

    int a = 3.14;
    cout << a << endl; //3 //자동으로 자료형변환

    //강제적으로 데이터형 변환
    //typeName(a) //바꿀데이터형(변수) //(바꿀데이터형)변수
    //c++ : static_cast<typeName>

    char ch = 'M';
    cout << int(ch) << endl << static_cast<int>(ch) << endl << ch;

    return 0;
    
}

4. 산술연산자와 auto

#include <iostream>

using namespace std;

int main(){

    /*
     연산자: + - * / %
     */

    // '/'에서 두 개의 피연산자가 모두 정수이면 '몫' 계산임
    // 계산에서 둘 중 하나가 실수형이면, 결과도 실수형으로 나옴
    int a = 3 + 2;
    cout << a; //5

    //연산 시 일반대수학의 우선순위를 따름 (곱하기, 나누기 > 더하기, 빼기)
    //곱하기와 나누기 간 순서는... 구글링해보기!

    /*auto*/
    auto n = 100; //int형으로 자동 지정
    //그러나 auto로 인해 의도와 다른 지정이 발생할 수 있으므로 사용 지양

}

 

 

728x90
728x90
#include <iostream> //전처리 지시자

/*
c++에서 함수를 사용 하고자 한다면
반드시 그 함수(ex.cout; 출력)의 원형을 미리 정의 하여야 한다
*/

using namespace std;
//세미콜론 ; 은 종결자의 역할: 한 문장의 끝으로 인식(엔터키 필요 없음)
//using namespace std가 없다면, 뒤 cout과 endl 앞에 'std::'를 추가로 붙여야 함

int main(){
    //c++ 코드에는 반드시 main의 이름을 가지고 있는 함수가 있어야 한다

    cout << "Hello, World!" << endl;
    //cout : 출력
    //꺽쇠 두 개 : 데이터의 흐름, 데이터의 방향을 나타냄
    //endl : 줄바꿈
    //std::cout<< "" <<std::endl;

    return 0;
}
  • 전처리 지시자: include <iostream>
  • 세미콜론을 통한 문장의 종결
  • using namespace std
    • std::
  • main의 이름을 가진 함수의 필요성
  • cout
  • 꺽쇠를 통한 데이터 흐름 표시
  • endl

reference: https://inf.run/JGFT

 

728x90

+ Recent posts