C# 정리

객체지향 프로그램 이란?
객체지향 개념(캡슐화, 정보은닉 ...)
프로그램 분석(객관식)
입출력(cin, cout)
클래스(인스턴스) 관계, 구성
객체 (사용)  동적생성/정적생성
접근제어 (public, private, protected)
멤버 변수/함수 외부정의
오버로딩(생성자)/ 오버라이딩
UML
생성자/소멸자 (순서)
멤버 초기화(상수 초기화 , 초기화 방법 3가지.)
this 포인터
정적멤버(static)
상속
부모생성자 명시적 호출

 

 

 

객체지향 프로그램 이란?

데이터와 함수를 하나의 덩어리로 묶어서 생각하는 방법이다.
데이터와 함수를 객체로 묶는 것을 캡슐화(encapsulation)라고 부른다.


- 데이터 알고리즘 둘 다 중요해짐
- 데이터 알고리즘을 class로 묶어서 객체라고 부름
- 객체 = 실제 세계를 모델링함

객체지향의 최종 목표
- 코드의 재사용

객체지향

- 실제 세계를 모델링해서 소프트웨어를 개발하는 방법

객체

- 객체는 상태와 동작을 가지고있음
- 객체 상태state = 속성 (변수타입
- 동작 behavior = 객체가 취할 수 있는 동작 (함수

클래스

- 클래스는 객체를 만들기 위한
- 객체를 만드는 설계도

인스턴스

- 클래스로부터 만들어진 객체들을 그 클래스의 인스턴스

객체지향 개념(캡슐화, 정보은닉 ...)

- 1캡슐화 ::데이터와 함수(연산)를 객체 안에 넣어 묶는 것
- 2정보은닉:: private 객체 내부의 데이터와 구현의 세부 사항을 외부 세계에서 감추는 것
- 3상속::부모클래스를 이어받음
기존의 코드를 재활용하기 위한 기법, 
이미 작성된 클래스(부모클래스)를 이어 받아서 새로운 클래스 (자식 클래스) 를 생성하는 기법
- 4다형성:: 객체의 동작이 상황에 따라 달라짐 
객체가 취하는 동작히 상황에 따라서 달라지는 것을 의미한다 -> 함수 이름의 재사용

 

프로그램 분석(객관식)

 

 

 

입출력(cin, cout)

 

C++에서는 콘솔 입력은 cin 객체가, 콘솔 출력은 cout 객체가 담당
이들은 모두 iostream 라이브러리에 포함

# Cout 객체

- 다양한 데이터 출력
- << 삽입연산자
- cout << 출력데이터 ;

# Cin 객체

- 다양한 데이터 입력 받음
- >> 추출 연산자
- cin >> 저장할변수;


cin >> num; //입력
 cout << "번호는 : " << num << "입니다" << endl; // 출력 

#include<iostream>
using namespace std;

int main() {
	printf("hello pc\n");
	std::cout << "hello\n pc" << std::endl;
	cout << "hello pc" << endl;

}

/* #include<stdio.h>

int main() {

	printf("hellp PC\n");

	return 0;
}
*/
//주석 처리 단축키

//#include<math.h> 
//C언어 개정 완료 C99 1999 잘 안바뀜
//C++ 3년마다 개정이 됨 (다를수있음)

#include<iostream> //input output 흐르다, 헤더파일
using namespace std; //기본적으로 써준다 , 이름공간설정 


void main() { // void . 리턴자 , 함수선언

	printf("hellp PC\n"); 
	//자릿수 맞출때 
	cout << "hello PC" << endl; 
	//프린트f 와 /n = endl = 자릿수 맞출 필요 없을 때
 //아무거나 사용해도됨

	cout << "hello PC"; //콘솔아웃 == 출력
	cout << "hello PC" << endl; 
	 cout << "hello PC" << endl;
	 cout << "hello" << "PC\n" << endl << "white" << endl;
	
	 //cin 입력

	 int num;
	 printf("번호를 입력해 주세요:  ");
	 cin >> num; // 화살표 >> num 안으로 들어간
	//scanf 서식지정자(형식)가 있었는데 없어짐
	 //C++은 형식을 없앰 자동으로 읽어옴
	 cout << "번호는 : " << num << "입니다" << endl; // 화살표 << 밖으로 출력

	// return; 
}

☆☆☆☆클래스(인스턴스) 관계, 구성 ###주관식 1문제

 

 

 

클래스(class): 객체를 만드는 설계도

클래스로부터 만들어지는 각각의 객체를 특별히 그 클래스의 인스턴스 (instance)라고도 한다.

 

class Car {}; // Car 클래스 생성 = 타입

Car c1, c2; // Car 타입 변수 선언 = 객체 생성

	c1.speed = 50; //멤버 변수 접근 = (.) 도트 연산자 사용
	c1.gear = 3;
	c1.start();
	c1.view();

객체 (사용)  동적생성/정적생성

클래스 = 타입

int main(void) {

//정적 생성 
	Car myCar;
    myCar.view();

//동적생성 new 와 delete 사용
	Car* myCar = new Car(); //포인터 메모리위치의 차이
	myCar->speed;
	myCar->view(); //메모리 누수가 생기니까 

	if (!myCar) //해제 여러번해버리면 문제 생기니까 조건식 넣어준다.
		delete myCar; //메모리 해제 시켜줘야함
}

 

접근제어 (public, private, protected)

 

 

#include<iostream>
using namespace std;

#private (디폴트) 전용멤버-클래스 안에서만 사용가능

class Car {
private: //데이터 현재 상태 값에 접근 안되게 주의
//기본 값은 private
	string color = "white";
	int speed = 0;
	int gear = 0;


# public 공용멤버-어디서든지 객체를 통하여 사용가능

public:
	void speedUp() { //함수를 통해서 제약을 건다.(조건통제)
//변수로는 조건통제가 불가능함
		if (speed > 100)
			speed = 0;
		else
			speed += 10;
	}

	void speedDown() {
		if (speed < 0)
			speed = 0;
		else
			speed -= 10;
	}

	void view() {
		cout << "speed = " << speed << endl;
		cout << "gear = " << gear << endl;
		cout << "color = " << color << endl;
	}

};


# protected 

상속관계에서 부모클래스에서 파생된 자식클래스가
부모클래스의 보호멤버를 사용할 수 있다.

class Emp {
	int rrn;
	
protected:
		int salary;
public:
	string name;
	void setSalart(int salary);
	int getSaltry();

};

class Manager : public Emp {
	int bonus;

public:
	Manager(int b = 0) : bonus(b) {}
	void modify(int s, int b);//함수원형 외부정의
	void display();
};

	void Manager::modify(int s, int b) { //함수 외부정의
		salary = s;
		bonus = b;

	}
};

 

멤버 변수/함수 외부정의

 

class Cat {
	void setEat(int e); // 5.함수 외부 정의 - 원형
};


void Cat::setEat(int e) { // 5.함수 외부 정의
	~~
}


멤버 함수가 클래스 내부에 정의되면 자동적으로 인라인(inline) 함수가 된
다. 
 멤버 함수가 클래스 외부에 정의되면 일반적인 함수와 동일하게 호출한다

#pragma once
#include<iostream>
using namespace std;

class Cat { //1.고양이 클래스 만들기

	string name; //2.멤버변수만들기
	bool sleep;
	int age;
	int hungry;
	string meow;
	string meow2;


public:

	Cat() { //7.생성자 만들기 (생성자 1번 , 내부정의)
		name = "NABI";
		sleep = 0;
		age = 0;
		hungry = 0;
		meow = "...";
		meow2 = "...";

	}

	//Cat(int a); //7.생성자 만들기 (<중복생성자> 매개변수 있는 생성자 2번 , 외부정의)


	void setName(string n) { //2.멤버함수만들기 , 3. set설정자
		name = n;
	};

	string getName() {  // 3.get접근자
		return name;
	};

	void setAge(int a) { 
		age = a;
	}

	/* void setAge(double a) { //11. double 값들어오면 반올림하기
		age = a;
		age = ceil(a);
	} */


	int getAge() {
		return age;
	}


	void setSleepOn() {
		sleep = true;
		meow = "Zzzz...";
	};

	void setSleepOff() {
		sleep = false;
		meow = "일어났어요.";
		setAttractOn();
	};
	
	void setEat(int e); // 5.함수 외부 정의

	int getEat() {
		return hungry;
	}

	void setAttractOn() {
		meow.append("Meow~♥");
	}
	void setAttractOff() {
		meow2.append(" Meow@#@^&#!#!!!!");
	}


	void view() {
		cout << " ======상태===== "<< endl;
		cout << " 이름   : " << name << endl;
		cout << " 나이   : " << age << endl;
		cout << " 배고픔 : " << hungry << endl << endl;
		cout << " ======대화===== " << endl;
		cout << "나      :" << name << ", 뭐해?" << endl;
		cout << name << "   : " << meow << endl << endl;
		cout << "나      :" << name << ", 배고프니?" << endl;
		cout << name << "   : " << meow2 << endl;
		cout << " =============== " << endl;
		
	}

	~Cat() { //소멸자
	}

};

void Cat::setEat(int e) { // 5.함수 외부 정의
	
	hungry = e;

	if (sleep == false) {
		if (e > 8) {
			meow2 = "배불러요";
		}
		else if (e == 0) {
			meow2 = "너무너무 배고파요";
			setAttractOff();
		}
		else if (0 < e <= 4) {
			meow2 = "배고파요";
		}
	}
	else {
		meow2 = "Zzz...";
	}
		
}

	/* Cat::Cat(int a) {//7.생성자 만들기 (<중복생성자> 매개변수 있는 생성자 2번 , 외부정의)
		name = "NABI";
		sleep = 0;
		age = a;
		hungry = 0;
		meow = "...";
		meow2 = "...";
	}
	*/

 

 

오버로딩(생성자)/ 오버라이딩

 

오버로딩 = 중복정의

class Car {
private:
	string color = "RED";
	int speed = 0;
	int gear = 0;

public:
	int getSpeed() { //접근자
		return speed;
	}
    
#멤버함수 중복 정의(오버로딩)가 가능

	void setSpeed(int s);
	void setSpeed(double s) { cout << "double" << endl; };
	void setSpeed(int s, double g) { cout << "int, double" << endl; };
	void setSpeed(double s, int g) { cout << "double, int" << endl; };
	void setSpeed(string c) { cout << "string" << endl; };

//

	c1.setSpeed(); //오류
	c1.setSpeed(10); // 곳이 정해져잇음 오류 안남
	c1.setSpeed(10,3.5); // 곳이 정해져잇음 오류 안남
}

--------------------------------
	//공 생성자
	// 디폴트 생성자
	//인수가 있는 생성자


	int getGear();
	void setGear(int g) { gear = g; }
	int getSpeed() { return speed; }


	int Car::getGear() {
		return gear;
	}

	void Car::setSpeed(int s) {
		if (speed > 100)
			speed = 100;
		else
			speed = s;
	}

오버라이딩 = 재정의

재정의(overriding): 자식 클래스가 필요에 따라 상속된 멤버 함수를 다시 정의하는 것

 

/* 부모 클래스의 멤버 함수와 동일한 시그니처를 가져야 한다. 
 즉 멤버 함수의 이름, 반환형, 매개 변수의 개수와 데이터 타입이 일치하여
야 한다. */


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

class Car {

public:
	int getHp()
	{
		return 100; // 100마력 반환
		}
};

class SportsCar :public Car {
public: 
	int getHp()
	{
		return 300; // 오버라이딩 = 재정의
	}
};

int main() {
	SportsCar sc;
	cout << "마력 :" << sc.getHp() << endl;
	return 0;
}

--------------

int main() {
	SportsCar sc;
	cout << ":" << sc.Car::getHp() << endl; //재정의 전 함수 호출
	return 0;
}

UML

UML(Unified Modeling Language):

애플리케이션을 구성하는 클래스들 간의 관계를 그리기 위하여 사용

 

생성자/소멸자 (순서)

 

객체의 생성
생성자()
객체의 사용
소멸자()
객체의 파괴

m.blog.naver.com/psychoria/40093564549

생성자(contructor):

객체가 생성될 때에 필드에게 초기값을 제공하고 필요 한 초기화 절차를 실행하는 멤버 함수

 클래스 이름과 동일하다
 반환값이 없다. 
 반드시 public 이어야 한다.
 중복 정의할 수 있다

-생성자 외부 정의 
	1. 디폴트 생성자
    


    
	2. 매개변수를 가지는 생성자
    
    
	3. 생성자 중복정의
	4. 생성자 호출
	5. 생성자 하나도 정의하지 않으면,
	6. 디폴트 매개변수
    7. 생성자에서 다른 생성자 호출
    
    
        A(int a, int b){
        m_a = a;
        m_b = b;
};

    
    A(int a, int b) : m_a(a), m_b(b){  // 초기화 리스트(Member Initialization List)
        //더 할 일
};

1. 상수 멤버 변수 초기화
class ABC{
public:
        const int A;
        ABC(int i) : A(i){}
};
 2. 레퍼런스 멤버 변수 초기화
 3. 포함된 객체의 초기화
 4. 상속 받은 멤버 변수를 초기화 할 때

소멸자는 클래스 이름에 ~가 붙는다. 
 값을 반환하지 않는다. 
 public 멤버 함수로 선언된다. 
 소멸자는 매개 변수를 받지 않는다.
 중복 정의도 불가능하다.
	1.소멸자
    ~Car() {
		}
    
 	2.디폴트 소멸자 //프로그래머가 소멸자 정의 하지 않았으면 자동삽입되어서 호출됨
    

public:
	Car() {
		speed = 100;
		gear = 3;
		color = "RED";
}

//생성할때 초기값 들어가고 , 생성자가 동작하면서 값이 들어감
//생성자 초기화할거면 생성할때 초기값 안넣어줘도됨


// 앞에 반환값 xx

public:
	Car() {
		speed = 100;
		gear = 3;
		color = "RED";
}

	Car(int g) {
		speed = 100;
		gear = g;
		color = "RED";
}

//생성자가 여러개라도 동작하는건 생성자 단 !! 1개 !!!!!!!!
// 인수

main {

Car c1; // 인수 없는
Car c2(20); //인수있는

 자동으로 맞춰서 들어감 
함수인데 객체 만들걸 선택가능


외부로 빼기

Car (int g);


	Car:: Car(int g) {
		speed = 100;
		gear = g;
		color = "RED";
}

//공생성자
//디폴트 생성자
Car () {
}

//인수가 있는 생성자
Car (int n) {
}


//소멸자
~Car() {
}

멤버 초기화(상수 초기화 , 초기화 방법 3가지.)

 

1. 상수 멤버 초기화 (독특)

Car(): speed(300) {
}
-------------
Car(int s, int g, string c) : spped(s), gear(g), color(c) { 
}

 

this 포인터

this는 현재 코드를 실행하는 객체를 가리키는 포인터

 

멤버변수

#include <iostream>

using namespace std;

class ThisPo {
    int n1;
    int n2;
public:
    //메소드의 매개변수랑 클래스의 멤버 변수 구별가능
    ThisPo(int n1, int n2) { 
        this->n1 = n1; //this->n1 멤버변수
        this->n2 = n2;
    }

    void print()
    {
    cout << this->n1 << endl;
    cout << this->n1 << endl;
       }
};

void main() {

    ThisPo num(2, 4);
    num.print();

    return;
}

 

 

 

정적멤버(static)

 

인스턴스 변수(instance variable): 객체마다 하나씩 있는 변수

정적 변수(static variable): 모든 객체를 통틀어서 하나만 있는 변수

static은 외부에서 초기화

class Car {
	static int count;
};

int Car::count = 0;

 

 

 

상속

 

: 기존에 존재하는 유사한 클래스로부터 속성과 동작을 이어받고 자신이 필요한 기능을 추가하는 기능

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

class Car {

	int speed = 10;

public:
	void setSpeed(int s) {
		speed = s;
	}

};

class sportCar :public Car { //상속
	bool turbo = false;
public:
	void setTurbo(int t) {
		turbo = t;
	}

	void view() {
		cout << "speed = " << speed << endl; 
		// 부모 상속이라고 해도  private는 접근 불가능 speed 오류 뜸
		cout << "turbo = " << turbo << endl; 
	}

};

void main() {
	sportCar s1;

	s1.speed = 100;
}

부모생성자 명시적 호출

 

Rectangle::rectangle(int x, int y, int w, int, y) : Shape(x, y) {
}