1107 프로그래밍 기초 문법 - 함수 포인터, 동적 메모리 할당, 사용자 정의 자료형, 객체지향언어 특징

함수 포인터

함수명 앞에 *만 붙여주면 함수 포인터가 선언된다.

자료형(함수 포인터 이름)(인자 목록)

• 함수 포인터도 포인터이므로 주소값 저장

함수포인터 사용 이유

• 메모리 크기 및 위치가 결정되는 시점은 컴파일 타임 또는 런타임 시점
• 컴파일 타임 시점 결정은 정적 바인딩, 런타임 시점 결정은 동적 바인딩
  • 컴파일 타임 : C언어 ➡️ int a = 10
  • 런타임 시점 : 자바스크립트 ➡️ var a = 10;

동적바인딩 예

• vs code의 extension들은 플러그인 방식으로 동작한다.
• 새 기능 추가하면 매번 다시 컴파일 해야 하는 불편함이 있으나 플러그인 방식 사용 시 그럴 필요 없다.
• 함수 포인터 사용은 프로그램의 유연한 확장성 제공
• 플러그인 : 규격맞 맞춰놓고 끼웠다 넣었다 할 수 있는 기능

---

구조체

• 하나 이상의 서로 다른 종류의 변수들을 묶어서 새로운 데이터 타입을 정의하는 것

구조체를 사용하는 이유

• 연관된 변수를 하나로 묶어 관리함으로써 데이터 관리에 유용
• 데이터 양(변수의 개수)이 많아지면 구조체가 유리함

구조체 정의

• 구조체 기본형태(학생 정보)

  struct student
  {
    char name[10];
    int age;
    int height;
  }

• struct 키워드는 구조체라는 데이터타입을 의미
• student는 내가 만든 구조체 이름
• name, age, height는 구조체 멤버

구조체 멤버에 접근하기

• 구조체 변수를 통해 구조체 멤버의 값을 참조해야 한다.
  [구조체 변수명].[구조체 멤버]
  ex) st1.name, st1.age...
• 멤버 접근 시 .[점] 사용을 직접 접근이라고 한다.

#include <stdio.h>
#include <string.h>

struct student {
   char name[10];
   int age;
   int height;
}st1;

int main() {
    strcpy(st1.name, "홍길동");
    st1.age = 20;
    st1.height = 170;

    printf("이름 : %s\n, 나이 : %d\n, 키 : %d\n", st1.name, st1.age, st1.height);
    return 0;
}

---

공용체

• 공용체도 사용자 정의 자료형이다.
• 구조체와 차이점은 메모리 공간을 공유한다는 점이다.
• 타입스크립트에서도 사용됨

---

열거형

• enumeration 약자로 enum이라고 읽음
• 데이터들을 열거한 집합. 연속적 데이터를 정의할 때
• 컴파일러는 열거형 멤버들을 정수형 상수로 취급한다.

  enum Week
  {
    sun = 0
    mon
    tue
    wed
    thu
  }

• 열거형 멤버들 각 요일 나타냄
• 첫번째 멤버 sun을 0으로 설정하면 다음 멤버 mon부터 1씩 증가

#include <stdio.h>
#include <string.h>

enum Week
{
    sun = 1,
    mon,
    tue,
    wed,
    thu,
    fri,
    sat
};

int main() {
    int day;


    printf("요일을 선택하세요 : ");
    scanf("%d", &day);

    switch(day){
        case sun:
            printf("일요일엔 짜파게티\n");
            break;
        case mon:
            printf("월요일\n");
            break;
        case tue:
            printf("화요일엔 짜파게티\n");
            break;
        case wed:
            printf("수요일엔 짜파게티\n");
            break;
        case thu:
            printf("목요일엔 짜파게티\n");
            break;
        case fri:
            printf("금요일엔 짜파게티\n");
            break;
        case sat:
            printf("토요일엔 짜파게티\n");
            break;
        default:
            printf("잘못입력하셨습니다.\n");
            break;
    }

    return 0;
}

---

메모리구조

메모리 영역

• 스택 영역 : 우리가 지금껏 사용한 지역변수 및 매개변수 등은 모두 스택 메모리 사용
• 매개변수 및 지역변수가 스택메모리에 어떤 구조로 저장되는지 보자
  

  

• 힙영역(큐 메모리) : 힙은 컴퓨터 메모리의 일부가 할당되었다가 회수되는 일들의 반복문
  • 힙은 컴파일 시가 아닌 실행 시 사용자로부터 할당 메모리를 입력 받음
    ➡️ 동적 메모리 할당
• 데이터영역 : 전역변수와 static 변수가 저장되는 메모리 영역, 이 메모리는 프로그램 종료시 소멸

동적 메모리 할당

동적으로 메모리 할당하는 이유

• 일반 변수 선언 : 메모리 할당은 컴파일 타임에 이루어진다. int a; ➡️ 정적 할당
• 전교생 10명인 학교의 학생수 배열로 선언한다면? int student[10]
• 학생수가 늘어나게 되면? int student[100]
  ➡️ 이는 미봉책에 불과. 학생수가 어떻게 변할지 모른다.
• 결국 학생 수는 유동적이므로 고정하지 말고 실행 시 결정하자

scanf("%d", &num);
int student[num];

• 문제점
  • scanf는 런타임에 실행
  • int student[num]은 컴파일타임에 실행
  • 런타임에 입력받은 변수를 컴파일 타임에 대입하는 형태는 시점 논리에 맞지 않는다.
• 해결방법
  • 동적 메모리 할당 기법 필요

동적 메모리 할당 및 해제

• 동적 메모리 할당 함수의 원형
  void* malloc(sizeof(int)*size);
  • 전달인자 size는 바이트 단위로 입력
  • 메모리 할당이 되면 메모리의 주소값을 리턴
  • 메모리 부족 시 NULL 포인터를 리턴
  • void* 의미 : 타입이 지정되지 않는 포인터.
    (메모리 크기만큼 할당해줄테니, 메모리는 원하는 형태로 정해서 사용하라)

#include <stdio.h>

int main() {
    int num;
    int *student;

    printf("학생 수 입력 :");
    scanf("%d", &num);

    // 스택 = 힙 메모리
    student = (int*)malloc(sizeof(int) * num);

    if(student == NULL){
        printf("메모리가 할당되지 않았습니다.\n");
        return 0;
    }

    printf("메모리 크기 : %d\n", sizeof(int)*num);
    free(student);

    return 0;
}

• 메모리 구조
  // 캡처
  

  

• 메모리 할당 후 반드시 메모리 해제해줘야 한다. (메모리누수 방지)
• 앞으로 객체 기반에서 new 연산자를 이용한 객체 생성의 메모리 구조는 모두 위 형태를 기반한다.

---

객체 지향 프로그래밍 방식

객체지향이란?

• 객체 : 영문으로 Object, 사물을 나타내는 추상적인 개념
• 지향 : 영문으로 Oriented, '~를 향한다'는 의미

구조적 프로그랭과 객체지향 프로그래밍

• 구조적 프로그래밍 방식 - 순차적, 하향식, 폭포수 방식
  • 기능적인 기본 단위는 함수이다.
• 객체지향 프로그래밍 방식
  • 기능 단위는 객체이다.
  • 대표적인 예가 이벤트 기반의 모든 윈도우 프로그램이다.
    ex> 메모장

추상화

• 추상 : 대상에서 특징만을 뽑아낸 것
• 우리 일상의 사물들은 관념적이고 추상적인 것들이 많다.
• 사물의 공통점을 묶는 속성이 추상화
• 객체지향의 철학 = 플라톤의 이데아?

캡슐화

• 은닉하다, 숨긴다의 의미
• 외부에서 내부를 볼 수 없게 한다는 의미
• 마냥 숨기기만 한다면 데이터는 무용지물
• 외부로부터 데이터를 조작할 인터페이스가 필요
• 하나의 캡슐단위가 클래스 = 사용자 정의 타입, 구조체와 유사
  • 클래스 = 데이터 + 메소드
  • 은닉된 데이터 : 프로퍼티 필드 속성 멤버변수
  • 멤버함수 : 메소드, 인터페이스

---

클래스란

• 사용자 정의 데이터 타입
• 데이터와 메소드를 사용자인 내가 새로 정의한 데이터타입이기 때문에
  클래스를 추상적인 데이터타입이라고 함.
• 클래스의 본질은 데이터타입이라는 점이다.
• 구조체와 비슷하다.
• 멤버 변수(데이터)와 멤버 함수(메소드)로 구성된다.

클래스의 구성

• 사물의 특성을 정리하여 필드와 메소드로 표현하는 과정이 추상화
• 추상화된 결과를 하나의 클래스에 포함시키고 스스로 보호하는 것이 캡슐화

클래스의 선언 형식

• 클래스 선언 시 class 키워드를 쓰고, 그 뒤에 클래스 이름을 붙인다.
• 클래스 요소로는 생성자, 멤버 변수, 메소드 등으로 구성

class 클래스 이름
{
    접근 지정자 클래스 이름(){...}
    접근 지정자 클래스 이름(){...}
    접근 지정자 데이터형 멤버 변수(필드);
    접근 지정자 데이터형 메소드();
}

• 접근 지정자
  • public : 누구나 접근 가능
  • private : 내 클래스 내부에서만 접근 가능, 외부 접근 불가
  • protected : 상속 관계에 있을 때 상속 받은 자식 클래스에서 접근 가능.

객체 선언

• 클래스의 본질은 데이터타입이다.
• 데이터타입을 통해 변수를 선언할 수 있다. 변수 선언한다.
• 클래스를 통해 선언한 변수를 객체라고 한다.

객체 생성

Dog a = new Dog();

➡️ a는 주소값 가지는 포인터

using System;

class Dog{
    private int eyes, nose, mouse, ears;
    public void bark(){Console.WriteLine("멍멍");}
}
class HelloWorld {
  static void Main() {
      Dog a = new Dog();
      a.bark();
  }
}

 

생성자의 개념

• 모든 변수는 선언이 되면 값을 초기화해야 함 ➡️ 초기화함수
• 객체도 본질적으로 변수이므로 선언되면 초기화해야 한다.
• 객체 생성 시 초기화 전용 메소드를 제공하는데 바로 생성자(constructor)이다.
• 객체 생성 시 자동으로 호출되는 메소드

// 생성자 : 초기화 전용 함수
public Dog(){
    eyes = 0;
    nose = 0;
    mouse = 0;
    ears = 0;
}

Dog a = new Dog();

using System;

class Dog{
    protected int eyes, nose, mouse, ears;
    public void bark(){Console.WriteLine("멍멍");}
    public Dog(){
        eyes = 0;
        nose = 0;
        mouse = 0;
        ears = 0;
    }
}

class Pudle : Dog{
  public Pudle() {
     base.eyes = 2;
     Console..WriteLine("푸들 눈 : {0}", eyes);
  }
}

상속성

부모 ⬅️ 자식

• 이미 완성된 클래스를 다른 클래스에 상속할 수 있다.
• 부모 클래스로부터 상속받을 때 클래스 이름 끝에 콜론(:)
  자바의 경우 extends 붙인 후 부모 클래스 이름 적음
• 프로젝트 관점에서 상속 개념
  • A프로젝트(종료됨)
  • B프로젝트(신규과제)
  • A프로젝트 기능이 B프로젝트의 기능과 유사함
  • B프로젝트는 A프로젝트를 상속 받고, 추가 기능만 구현하면 됨

---

다형성

• 함수 이름이 같더라도 전달인자의 타입이나 개수에 따라 구분된다.
• 객체지향에서는 대표적으로 오버로딩과 오버라이딩 기법이 있다.

오버로딩

• 과적하다, 적재하다 라는 의미
• 겉모습은 똑같지만 내용이 다른 경우
• 이름이 같은 함수일지라도 전달인자 타입이나 개수가 다른 경우
• 스타크래프트 오버로드 유닛의 예
• 코드로 풀어보면 같은 이름의 함수에 같은 개수의 전달인자가 서로 다른 타입으로 존재

using System;

public class Zerg{
    public void Overload(int zerggling){
        Console.WriteLine("저글링 {0}마리", zerggling);
    }

    public void Overload(int zerggling, int hydra){
        Console.WriteLine("저글링 {0}마리 + 히드라 {1}마리", zerggling, hydra);
    }

    public void Overload(int zerggling, int hydra, int lurker){
        Console.WriteLine("저글링 {0}마리 + 히드라 {1}마리 + 럴커 {1}마리", 
        zerggling, hydra, lurker);
    }

    public void Overload(char zerggling){
        Console.WriteLine("저글링 {0}등급", zerggling);
    }
}
class HelloWorld {
  static void Main() {
      Zerg zerg = new Zerg();
      zerg.Overload(10);
      zerg.Overload(10, 20);
      zerg.Overload(10, 20, 30);
      zerg.Overload('A');
  }
}

 

오버라이딩

• 위로 올라탄다, 엎어친다는 의미
• 기존의 것을 덮어버린다는 개념
• 상속의 개념이 기반이 되어야 한다.

using System;

class Dog{
    protected int eyes, nose, mouse, ears;
    virtual public void bark(){Console.WriteLine("멍멍");}
    public Dog(){
        eyes = 0;
        nose = 0;
        mouse = 0;
        ears = 0;
    }
}

class Pudle : Dog{
  public Pudle() {
     base.eyes = 2;
     Console.WriteLine("푸들 눈 : {0}", eyes);
  }

  public override void bark(){Console.WriteLine("왈왈");}
}

class HelloWorld {
    static void Main(){
        Dog dog = new Dog();
        dog.bark();
        Pudle pd = new Pudle();
        pd.bark();

        dog = new Pudle();
        dog.bark();
    }
}

---

인터페이스

• 메소드의 목록만을 가지고 있는 명세(Specification), 사용자 정의 타입이다.
• 메소드의 목록만 선언하고 구현은 하지 않는다.
• 인터페이스의 선언 형태

접근지정자 interface 이름 : 기반인터페이스
{

}

• 인터페이스를 상속받는 클래스 형태

접근지정자 class 자식클래스이름 : 인터페이스
{

}

 

인터페이스 사용하는 이유

• 인터페이스는 본체가 정의되지 않는 추상메소드만 갖는다.
• 목적은 기존의 기능을 추가/수정하는 개념보다는 동일한 개념의 기능을 새롭게 구현하는 기능
• 공동작업 시 표준을 정하는 역할

추상클래스를 상속하는 경우

• 일반적으로 클래스를 상속하는 이유는 기능의 확장이 목적

인터페이스를 상속하는 경우

• 상속관계의 개념이 아니라 여러가지 기능의 나열
• 인터페이스에서 기능을 명세하고, 자식클래스에서 상속한다.
• 인터페이스는 상속이 아니라 구현의 의미로 implements 사용

using System;

public interface IUnit{
    void Attack();
    void Move();

}

public class Zergling : IUnit{
    public void Attack(){
        Console.WriteLine("저글링 : 공격한다.");
    }

    public void Move(){
        Console.WriteLine("저글링 : 이동한다.");
    }
}

public class Dragoon : IUnit{
    public void Attack(){
        Console.WriteLine("드라군 : 공격한다.");
    }

    public void Move(){
        Console.WriteLine("드라군 : 이동한다.");
    }
}

class HelloWorld {
    static void Main(){
        Zergling zerg = new Zergling();
        zerg.Attack();
        zerg.Move();

        Dragoon dragoon = new Dragoon();
        dragoon.Attack();
        dragoon.Move();
    }
}

 

메모리 관리

• 플랫폼 기반의 객체 지향 언어는 가비지 컬렉터가 메모리를 자동관리한다.
• 백그라운드에서 더이상 사용되지 않는 메모리를 찾아 회수한다.

---

람다를 통한 화살표 함수의 이해

익명 메소드

• 메소드를 미리 정의하지 않고 사용할 때 정의한다.
• 익명 메소드를 사용하면 코드가 간결해진다.
• 익명 메소드는 별도의 메소드를 만들지 않으므로 코딩 오버헤드를 줄일 수 있다.
• 내용 자체가 목잡하면 안된다.
• 익명 메소드는 람다식에서 사용됨다.

람다식이란

• 기존 익명 메소드를 더욱 간결하게 만든다.

using System;
class HelloWorld {
    static int Add(int a){
        return a + 1;
    }
    delegate int CalcDele(int x);

  static void Main() {
    Console.WriteLine(Add(3));

      CalcDele d = delegate (int x){
          return x + 1;
      };

      Console.WriteLine(d(3));
  }
}

 

람다식표현

(인수)=> 표현식 또는 명령문

delegete 키워드를 사라지며 화살표로 대체한다.

CalcDele d = x => x + 1;