또리야 개발하자

//*************************************************
// static 키워드 !! 
//*************************************************
#include 

using namespace std; 

// static 멤버 변수  :   클래스당 하나의 변수만 필요한 경우 !!   
// static 멤버 함수 

class KY_Student
{	
public: 
	static char SchoolName[100]; //학교이름  
            int m_age; 
};
// static 멤버 변수는 반드시 외부에서 초기화가 되어야 한다!! 
char KY_Student::SchoolName[100] = "건양대학교"; 	



void main()
{
	KY_Student s[5];
	// 클래스 이름을 통해 접근 !! 
	// static멤버변수는 객체마다 할당되는 것아리나 클래스당 1개가 할당 !! 
	// 객체가 아닌 클래스의 이름으로 접근가능하다 !! 
	cout << KY_Student::SchoolName << endl;

}

//*****************************************************
//	static  멤버 함수와 함수의 활용 !! 
//*****************************************************
#include 
using namespace std;


// 마린 !! 
class Marin 
{
public: 
                 int m_hp;    //체력 
    const static  int m_price; //가격
			static int m_att;	   // 공격력 
			static int m_def;    // 방어력 
	
public : 
	// setter/getter 
	int getHp()	 const { return m_hp; }
	int getPrice() const  { return m_price; }
	int getAtt()   const  { return m_att; } 
	int getDef()   const  { return m_def;}
	
	// static멤버 함수안에서는 static멤버 변수만 접근 할수 있다 !! 
	static int Attup(){ return m_att++;  m_hp++;   }
	static int Defup(){ return m_def++;  }


	Marin() // : m_price(50) //const멤버 초기화 
	{
		m_hp = 40; 
		m_att = 1; 
		m_def = 1; 
	}
	void ShowMarinInfo() const 
	{
		cout << "가격 : "    << m_price << endl;
		cout << "체력 : "    << m_hp << endl; 
		cout << "공격력  : " << m_att << endl; 
	}

};
// 외부에서 초기화 !! 
const int Marin::m_price = 50; 
int Marin::m_att = 1; 
int Marin::m_def = 1; 



void main()
{	

	Marin::Attup(); 
	Marin::Defup(); 


}

//****************************************************
//	const멤버의 이해 !! 
//****************************************************
// const 키워드에 대해 알아보자 !! 
//****************************************************
#include 
using namespace std; 
//const :  상수화 ---> 값을 변경하지 못하도록 한다 !! 
#define SIZE 100  

// const 멤버 변수 : 멤버 변수중에 절대 값을 바꾸면 안되는 경우 사용 !! 
class Student 
{
private: 
     const   int m_StudentNo; // 값을 변경하지 못한다!! 
	 const bool m_sex;
			  int  m_age; 
public :	// 초기화 리스트 :  이니셜라이저 !! 
	Student() :  m_StudentNo(1000) , m_sex(true), m_age(20)    //생성자 
	{//  const멤버 변수는 생성자에서 초기화 불가능하다 !! 
	 // 반드시 초기화 리스트를 통해서만 초기화 가능하다 !! 
	//	m_StudentNo = 1000; 
	//	m_sex  = true; 
	}
	Student( int no ,  bool sex , int age ) : 
	m_StudentNo(no), m_sex(sex), m_age(age) //초기화 리스트 !! 
	{
		
	}
	void Show() { cout << m_StudentNo << m_sex << m_age << endl; }
	
};
void main()
{	
	Student s; 
	s.Show();
	// 변수의 값으 변경하지 못하게 할때 !! 
//	const int MAX = 100; // 선언과 동시에 초기화 !!	
//	cout << MAX++ << endl;

}

//****************************************************
// const 멤버 함수의 선언과 사용 !! 
//****************************************************
// const 멤버함수 :  함수안에서 멤버 변수의 값을 변경 불가능 !! 
#include 
using namespace std;

class  Car 
{
private: 
const int m_CarNo; 
	   int m_Year; //연식 
public :
	Car() : m_CarNo(1000) { m_Year = 2000; } 
	
	void CarInfo() const // ==> 이함수에서는 절대 멤버 변수의값을 변경불가능 !! 
	{	
		// const함수에서는 절대 일반 멤버 함수를 호출 할수 없도록 한다 !! 
		// 문법적인 오류를 발생 시킨다 !! 
		cout << m_CarNo << setYear(1000)  << endl; 
	}
	void setYear( int NewYear) const  { m_Year  = NewYear; }

};


void main() 
{
	

}

//*****************************************************
//	const 멤버 함수와 함수의 활용 !! 
//*****************************************************
#include 
using namespace std;

// 마린 !! 
class Marin 
{
private: 
                 int m_hp;    //체력 
    const static  int m_price; //가격
			static int m_att;	   // 공격력 
			static int m_def;    // 방어력 

public : 
	// setter/getter 
	int getHp()	 const { return m_hp; }
	int getPrice() const  { return m_price; }
	int getAtt()   const  { return m_att; } 
	int getDef()   const  { return m_def;}

	Marin() : m_price(50) //const멤버 초기화 
	{
		m_hp = 40; 
		m_att = 1; 
		m_def = 1; 
	}
	void ShowMarinInfo() const 
	{
		cout << "가격 : "    << m_price << endl;
		cout << "체력 : "    << m_hp << endl; 
		cout << "공격력  : " << m_att << endl; 


	}

};



void main()
{

}

//*******************************************
// 객체 지향의 3대요소 !
//*******************************************
// 1) 캡슐화  
// 2) 상속
// 3) 다형성
//*******************************************
// 추상화  :  실존하는 객체에 대한 추상 !! 
// ==>   사람  --> 졸라맨  
// --> 세포, 감정, 신체활동 
// -->  머리 --팔- 몸통 -다리 !! 
// 프로그램상에 필요한 많은 객체를 모두 표현하기에는  
// 무리이다. 그래서  프로그램에 필요한 만큼의 속성만을 
// 객체로부터 표현하는것 !! 

// 객체 ?? 
// --> 행동 +  속성  
// --> 기능 + 데이타 
// --> 행위 + 데이타  

// 자신만의 고유한 속성을 갖고 독립적인 행동을 취하는 
// 사물, 사건, 현상 등등의 모든것을 말한다 !! 


// --> 세상에 존재하는 모두 사물들이다.. 등등 !! 

#include 

using namespace std;

class Person
{
private:
	int m_age; 
	char m_name[20]; 
	char * m_addr;

public: 
	// 생성자 : 객체 멤버의 초기화  
	// 1) 클래스의 이름과 동일하다 !! 
	// 2) 생성자는 리턴이 없다. --> void :  리턴 값이 없는경우 !!!
	// 3) 객체 생성시에 자동으로 호출을 해준다. 
	// 4) 함수 오버로딩이 가능하다 !! 
	// 5) 생성자를 작성하지 않으면 디폴트 생성자를 만들어 준다 !! 
	// 6) 오버로딩된 다른 버전의 생성자가 있으면 컴파일러가 더이상 
	// 디폴트 생성자를 만들어 주지 않는다..
	Person()
	{
		m_age = 20; 
		strcpy(m_name, "홍길동"); 
		m_addr = new char[200];
		strcpy( m_addr, "충남 논산시 와야리"); 

	}
	Person( int age) 
	{
		m_age = age; 
		strcpy(m_name, "홍길동"); 
	}
	Person( int age ,  char * name) 
	{
		m_age = age; 
		strcpy( m_name, name);
	
	}
	// 소멸자 : 
	// 객체가 소멸이 될때 자동으로 호출되는 함수 !! 
	// 1) 클래스와 이름이 동일하다 !!
	// 2) 생성자와 구별하기 위해 ~을 붙여준다 !! 
	// 3) 리턴이 없다.
	// 4) 오버로딩이 불가능 ( 1개만 존재한다) 
	// 객체의 정리 작업 !! 
	// 객체가 동적할당, 시스템의 자원 활용, 네트워크 자원등을 
	// 정리하는 작업 !! 
	~Person() 
	{
		// 객체가 메모리에서 사라질때 
		// 자동으로 수행해야할 작업들 정의 !! 
	    delete [] m_addr; 
	}



	void ShowInfo()
	{
		cout << "나이 : " << m_age <<"이름 :" << m_name << endl;
	}
	void Create(){} 
	void Die(){}
}; 
void main()
{
	Person Bow; 
	Bow.ShowInfo();

}

//************************************************
// 구조체 : 여러가지 속성의 조합으로 하나의 새로운 타입을
// 만들어내는 방법!! 
//************************************************

#include 

using namespace std;
// c++에서는 구조체에도 함수들을 정의 할수 있다 !! 
// 하지만, 좀더 나은 OOP구현을 위해 새로운 키워드 !!
// class : 객체의 행동과 속성을 구현하기 위한 도구 !! 

// public :  프로그램 어디에서나 클래스 내의 멤버에 접근이 가능 !! 
// private : 클래스 내부에서만 접근 가능한 멤버  

// struct 는 선언 하지않아도 기존으로 public의 접근 권한 !! 
// class는 기본적으로 private의 접근 권한을 갖는다. 

// 일반적인  설계 규칙!!
// 멤버 변수 : private
// 멤버 함수 : public 

//멤버변수는 그객체의 고유한 값을 갖고 있고... 
//public한 멤버 함수들을 통해서 통체 및 제어 가 되어야 한다 !! 



class Person 
{
	// 속성 
private: 
	float bt; 
	int age; 
	bool sex;
	float bw; 
	char name[20]; 
	// 행동 
public :
	void eating(){
		 bt++;
		 bw++; 
	} 
	void Sleep()
	{
		bt--; 
		bw--; 
	} 
	void Love()
	{
		bt++; 
	} 
};
/*
void eating(Person ss )
{

}

void Love(Person ss)
{

}*/

void main()
{
	// C언어 방식의 프로그램
	//-> 함수 중심의 언어 
	// --> 기능 중심으로 프로그램을  작성해 나간다 !! 
 	/*Person SolSan; 
	eating(SolSan); 
	Love(SolSan);*/
	// C++방식의 프로그램 
	// -> 객체 중심의 언어 !! ( OOP ) 
	// -> 객체( 데이타)를 중심으로 프로그램을 작성한다 !!
	 // OOP : ㅒObject Oriented Programing !
	// --> 객체 지향 --. 
	// --> 객체를 중심으로 프로그램을 작성 !! 
			// Bow 
	Person Bow; //객체 선언 !! 
	//Bow.bt++; 
	//객체 --> 실제 메모리에 로딩되는 인스턴스 
	Bow.Love(); 
	Bow.Sleep(); 
	 // OOP는 데이타 중심의 프로그래밍 방식 !! 

}

//========================================================
// 함수 오버로딩 
//========================================================
// 같은 이름의 함수 매개변수의 갯수나 타입에 따라서 서로다른 함수로 인식 !! 
// ---> 같은 이름의 함수가 여러개 존재 가능하다... 

#include 
using namespace std;
/*
int Sum(int x, int y) 
{
	return x + y;
}
double Sum( double  x , double y) 
{
	return x +y; 
}
int Sum( int x)
{
	return x + x; 
} 
void Sum(int x)
{
	cout << x + x << endl; 
}*/

// 같은 로직 비슷한 기능을 구현하고 있지만... 
// 타입에 따라서 여러가지 버전의 함수를 만들어야할 경우 !!
// 계산기 !! 
/*
void multi(int x ,  int y) {} 
void multi(float x,  int y){} 
void multi(int x,  float y){} 
void multi(float x , float y){} 
*/ 

// 사람을 초기화 하는 함수 !! 

void InputPerson( int age ) {}
void InputPerson( int age ,  char * name){} 
void InputPerson( int age, char *name, double money){}









void main()
{
	InputPerson(
//	cout <<  Sum( 10, 20) << endl; 
	
}

//*************************************************
//  달라진점 
//*************************************************
#include 

using namespace std;
//**********************************************************
// 구조체의 태그가 바로 이름이 된다 !! 
//**********************************************************
struct Student
{
	int sno;
	char *name; 
};
//**********************************************************
//전역 변수 
int x = 8888;

void main()
{	
	Student s1; 
	//0 : 거짓 나머지 : 참
	//*************************************************************
	// bool 타입 
	//*************************************************************
	bool flag = false; 
	flag  = true; 
	// C언어에서는 true,false 명확하지 않았다. !! 

	int x = 999; 
	cout << x << endl; 
	int y = 20; 
	//**********************************************************
	// 캐스팅 --> 강제 형변환 !!--> A타입에서 B타입으로 변경 !! 
	char z = (char)x; // 암시적인 형변환 
	char z1 = char(x); // 명시적인 형변한 
	//**********************************************************
	int * p = (int*)malloc(sizeof(int)); 

	for(int i = 0; i<10; i++) 
	{
	//**********************************************************
	// 함수 어디에서나 변수 선언 가능 
	//**********************************************************
		int x = 1111; 
	//**********************************************************
		// :: 범위연산자 :  전역변수 혹은 함수를 불러올때
		// :: 네임스페이스에 소속된 멤버를  불러올때..
		// std::cout 
		cout << ::x  << endl;
	//**********************************************************	
	}
}

//************************************************
//  malloc :  메모리 관리 
//************************************************
// C++언어에서는 동적메모리를 적극적으로 사용한다 
// new : java, C# 
// --> malloc --> new !! 
// delete --> free 

#include 
using namespace std;

struct Person 
{
	int age;
	char name[20];
};
void main()
{	
//  동적배열 
//	int * p =  new int[10]; 
//--> int * p =  (int*)malloc(sizeof(int)*10); 

	Person * list =  new Person[10]; 
	
	list[0].age = 10;
	strcpy( list[0].name , "홍길동") ;

	delete [] p; 
	//free(p); 
	
	// malloc VS new 
	// 1. malloc은함수이기 때문에 별도에 인클루드가 필요하다 .
	// 2. new 연산자 이기때문에 인클루드 없이 프로그램 어디서든 사용가능 
	// 3. mallc은 void * 를 리턴하기때문에 별도에 캐스팅이 필요하다 !!
	// 4. new는 알아서  생성에 맞는 타입의 포인터를 리턴해준다 !!
	// 5. new와 delete는 객체의 생성자와 소멸자를 자동으로 호출하는 역할 !! 
	// 6. class의 객체 생성시에는 반드시 new/delete를 사용해야 한다 !! 





}

//*******************************************************
//  개선 사항 !! 
//*******************************************************
//#include  
#include  
using namespace std;  
// namespace --> 이름공간 !! 
// 논리적으로 구분하는 프로그래밍 단위 --> NAMESPACE -> 패키지
//--> 파일 물리적으로 구분!! 
/*
namespace KY 
{
	int myKY; 
}
namespace BIT
{
	int myKY; 
}

using namespace KY; 
using namespace BIT; 
*/


void main()
{		
	// 연산자 오버로딩 !!
	// --> 기존의 연산자를 객체와 결합해서 새로운 의미의 연산자로 사용하는것 !! 
	//cout.operator<<("hello C++");
	// 타입을 명시해 주지 않아도 출력이 가능하다 !! 
	int x;
	cout << 10 << 3.14 << 'a' <<  endl; 
	cin >> x ;
	cout << x << endl;


}

#include 
#include 
#include 

#define BUFSIZE 512
#define FD_SETSIZE 128

// 소켓 정보 저장을 위한 구조체
struct SOCKETINFO
{
	SOCKET sock;
	char buf[BUFSIZE+1];
	int recvbytes;
	int sendbytes;
};

int nTotalSockets = 0;
SOCKETINFO *SocketInfoArray[FD_SETSIZE];

// 소켓 관리 함수
BOOL AddSocketInfo(SOCKET sock);
void RemoveSocketInfo(int nIndex);
int FD_setadd(int add);
// 오류 출력 함수
void err_quit(char *msg);
void err_display(char *msg);

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

	// 윈속 초기화
	WSADATA wsa;
	if(WSAStartup(MAKEWORD(2,2), &wsa) != 0)
		return -1;

	// socket()
	SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
	if(listen_sock == INVALID_SOCKET) err_quit("socket()");

	// bind()
	SOCKADDR_IN serveraddr;
	ZeroMemory(&serveraddr, sizeof(serveraddr));
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(9000);
	serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
	retval = bind(listen_sock, (SOCKADDR *)&serveraddr, sizeof(serveraddr));
	if(retval == SOCKET_ERROR) err_quit("bind()");
	
	// listen()
	retval = listen(listen_sock, SOMAXCONN);
	if(retval == SOCKET_ERROR) err_quit("listen()");

	// 넌블로킹 소켓으로 전환
	u_long on = TRUE;
	retval = ioctlsocket(listen_sock, FIONBIO, &on);
	if(retval == SOCKET_ERROR) err_display("ioctlsocket()");

	// 데이터 통신에 사용할 변수
	FD_SET rset;
	FD_SET wset;
	SOCKET client_sock;
	SOCKADDR_IN clientaddr;
	int addrlen;

	while(1){
		// 소켓 셋 초기화
		FD_ZERO(&rset);
		FD_ZERO(&wset);
		FD_SET(listen_sock, &rset);
		for(int i=0; irecvbytes > SocketInfoArray[i]->sendbytes)
				FD_SET(SocketInfoArray[i]->sock, &wset);
			else
				FD_SET(SocketInfoArray[i]->sock, &rset);
		}
		FD_setadd(FD_SETSIZE);
		// select()
		retval = select(0, &rset, &wset, NULL, NULL);
		if(retval == SOCKET_ERROR) err_quit("select()");

		// 소켓 셋 검사(1): 클라이언트 접속 수용
		if(FD_ISSET(listen_sock, &rset)){
			addrlen = sizeof(clientaddr);
			client_sock = accept(listen_sock, (SOCKADDR *)&clientaddr, &addrlen);
			if(client_sock == INVALID_SOCKET){
				if(WSAGetLastError() != WSAEWOULDBLOCK)
					err_display("accept()");
			}
			else{
				printf("[TCP 서버] 클라이언트 접속: IP 주소=%s, 포트 번호=%d\n", 
					inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
				// 소켓 정보 추가
				if(AddSocketInfo(client_sock) == FALSE){
					printf("[TCP 서버] 클라이언트 접속을 해제합니다!\n");
					closesocket(client_sock);
				}
			}
		}

		// 소켓 셋 검사(2): 데이터 통신
		for(int i=0; isock, &rset)){
				// 데이터 받기
				retval = recv(ptr->sock, ptr->buf, BUFSIZE, 0);
				if(retval == SOCKET_ERROR){
					if(WSAGetLastError() != WSAEWOULDBLOCK){
						err_display("recv()");
						RemoveSocketInfo(i);
					}
					continue;
				}
				else if(retval == 0){
					RemoveSocketInfo(i);
					continue;
				}
				ptr->recvbytes = retval;
				// 받은 데이터 출력
				addrlen = sizeof(clientaddr);
				getpeername(ptr->sock, (SOCKADDR *)&clientaddr, &addrlen);
				ptr->buf[retval] = '\0';
				printf("[TCP/%s:%d] %s\n", inet_ntoa(clientaddr.sin_addr),
					ntohs(clientaddr.sin_port), ptr->buf);
			}
			if(FD_ISSET(ptr->sock, &wset)){
				// 데이터 보내기
				retval = send(ptr->sock, ptr->buf + ptr->sendbytes, 
					ptr->recvbytes - ptr->sendbytes, 0);
				if(retval == SOCKET_ERROR){
					if(WSAGetLastError() != WSAEWOULDBLOCK){
						err_display("send()");
						RemoveSocketInfo(i);
					}
					continue;
				}
				ptr->sendbytes += retval;
				if(ptr->recvbytes == ptr->sendbytes){
					ptr->recvbytes = ptr->sendbytes = 0;
				}
			}
		}
	}

	// 윈속 종료
	WSACleanup();
	return 0;
}

// 소켓 정보 추가
BOOL AddSocketInfo(SOCKET sock)
{
	// FD_SETSIZE - 연결 대기 소켓
	if(nTotalSockets >= (FD_SETSIZE-1)){
		printf("[오류] 소켓 정보를 추가할 수 없습니다!\n");
		return FALSE;
	}

	SOCKETINFO *ptr = new SOCKETINFO;
	if(ptr == NULL){
		printf("[오류] 메모리가 부족합니다!\n");
		return FALSE;
	}

	ptr->sock = sock;
	ptr->recvbytes = 0;
	ptr->sendbytes = 0;
	SocketInfoArray[nTotalSockets++] = ptr;

	return TRUE;
}

// 소켓 정보 삭제
void RemoveSocketInfo(int nIndex)
{
	SOCKETINFO *ptr = SocketInfoArray[nIndex];

	// 클라이언트 정보 얻기
	SOCKADDR_IN clientaddr;
	int addrlen = sizeof(clientaddr);
	getpeername(ptr->sock, (SOCKADDR *)&clientaddr, &addrlen);
	printf("[TCP 서버] 클라이언트 종료: IP 주소=%s, 포트 번호=%d\n", 
		inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));

	closesocket(ptr->sock);
	delete ptr;

	for(int i=nIndex; i= FD_SETSIZE)
	{
		add++;
	}
	return add;
}