'프로그래밍 기초/C++'에 해당되는 글 5건

  1. 2010.05.11 반올림함수 만들기
  2. 2010.03.04 가상함수테이블
  3. 2010.03.04 다형성
  4. 2010.01.24 This 포인터
  5. 2009.11.20 템플릿이란!?

C++에서 제공해주지 않는 반올림 함수를 만들어보자~

1.첫번째

double round( double value, int pos )

{

      double temp;

      temp = value * pow( 10, pos );  // 원하는 소수점 자리수만큼 10의 누승을 함

      temp = floor( temp + 0.5 );          // 0.5를 더한후 버림하면 반올림이 됨

      temp *= pow( 10, -pos );           // 다시 원래 소수점 자리수로

      return temp;

}
 

2.두번째

double Round(double x, int n)
{
       int i;
       // 자릿수맞춤
       for ( i = 0; i < n; ++i )
             x *= 10;
       if ( x - (int)x >= 0.5 )
             // 소수점이하부분이0.5보다크거나같으면올림
             x = ceil(x);
       else
             // 작으면버림
             x = floor(x);           
       // 자릿수복구
       for ( i = 0; i < n; ++i )
             x /= 10;

'프로그래밍 기초 > C++' 카테고리의 다른 글

가상함수테이블  (0) 2010.03.04
다형성  (0) 2010.03.04
This 포인터  (0) 2010.01.24
템플릿이란!?  (0) 2009.11.20
Posted by 아몰라
                      


출처 - http://cafe.naver.com/gisdev

'프로그래밍 기초 > C++' 카테고리의 다른 글

반올림함수 만들기  (0) 2010.05.11
다형성  (0) 2010.03.04
This 포인터  (0) 2010.01.24
템플릿이란!?  (0) 2009.11.20
Posted by 아몰라

다형성이란?

다형성이란 모습은 같은데 형태는 다르다는 뜻으로 C++ 기본 철학이고 매우 중요한 개념이지만
어떠한 정형화된 개념은 아니다. C++에는 여러 곳에서 다형성이 사용되며 여기서 2개정도 설명하겠다.


다형성의 사용 목적

:  프로그래머는 프로그램을 만드는것 보다 프로그램을 만든 후 그 프로그램에 대하여 유지, 보수에 더 신경을 써야 하며

 더 많은 시간을 투자하게 된다.

  다형성은 프로그래머가 프로그램을 만드는데에 있어 클래스와 클래스의 관계를 유연하게 해주어

 스펙의 변경, 추가 등에 대하여 유연하게 대처 할 수 있도록 해준다.

  다형성을 사용하지 않아도 프로그램은 만들어진다. 단지 나중에 스펙의 변경, 추가 따위에

 유연하게 대처 할 수 없을 수 있으며 최악의 경우 프로그램을 처음부터 다시 만들어야 하는 경우가 생기게 된다.

 

다형성의 특징

: 다형성을 이용하게 되면 하위 클래스에서 상위 클래스의 메서드를 오버라이드하여도

상위 클래스의 메서드들이 호출된다.

 멤버 변수도 마찬가지 이다. 하위 클래스에서 멤버 변수에 값을 변경 하여도 상위 클래스에서의 멤버 변수의 값이

호출된다.



예 2가지

1. 오버로딩

C에서는 같은 함수명을 여러번 중복정의할수 없었지만 C++에서는 매개변수명이나 반환형이 다르면 같은 함수명이라도
여러번 중복 정의할 수 있다. 오버로딩도 다형성중에 한 예라고 할 수 고  프로그래머가 어느 함수를 써야될지를 고민하지 않아도 된다.  

foo1(int a, int b)                       foo(int a, int b)
foo2(int c, long d)                    foo(int c, long d)

2. 동적바인딩

class A
{
virtual void fct(){}
}

class B : public A
{
 void fct(){}
}

int main()
{
  A * a = new B();
  a->fct();
}

a라는 이름의 포인터가 가리키는 대상에 따라서 기능의 형태(호출되는 함수, 혹은 출력결과)는 다르게 나타난다. 이것이 다형성이다.  그리고 class A 와 class B 역시 똑같은 함수를 쓰고 있다. 이것도 다형성의 한 예이다.

'프로그래밍 기초 > C++' 카테고리의 다른 글

반올림함수 만들기  (0) 2010.05.11
가상함수테이블  (0) 2010.03.04
This 포인터  (0) 2010.01.24
템플릿이란!?  (0) 2009.11.20
Posted by 아몰라

This는 자기 자신을 가르키는 용도로 사용된다. 그래서 자기 참조 포인터라 한다.

class Member 
{

 int Test1;
 int Test2;
public:
 Member(int Test1, int Test2 )
 {
  this->Test1 = Test1;
  this->Test2 = Test2;
 }
 virtual ~Member();
 void View()
 {
  cout<<Test1 <<endl <<Test2<<endl;
 }
 

};
 

int main()
{
 Member M(1, 2);
 M.View();
 return 0;
}


Test1, Test2 은 매개 변수 와 클래스 멤버변수와 이름이 겹친다

하지만 매개변수는 지역변수이므로 그 안에서 멤버변수 Test에는 접근할 수 없다

방법은 this 포인터를 이용해서 해당 객체의 멤버변수를 직접 가르키면 된다


class Member 
{

public:
 
 Member * GetThis()
 {
  return this;
 }
 

};

int main()
{
 Member * p1 = new Member();
 cout<<"포인터 p1 " << p1<<endl;
 cout<<"p1 의 this " << p1->GetThis()<<endl;

 Member * p2 = new Member();
 cout<<"포인터 p2 " << p2<<endl;
 cout<<"p2 의 this " << p2->GetThis()<<endl;

 return 0;
}



'프로그래밍 기초 > C++' 카테고리의 다른 글

반올림함수 만들기  (0) 2010.05.11
가상함수테이블  (0) 2010.03.04
다형성  (0) 2010.03.04
템플릿이란!?  (0) 2009.11.20
Posted by 아몰라

//템플릿이란!!?? 함수를 템플릿화하면 자료형은 결정되지않는다! 자료형을 자유롭게!!!

////////////////////////////////////////////////////////////////////////////////////

#include <iostream>
using::std::endl;
using::std::cout;

template <typename T>   //템플릿은 모형자!

T Add(T a, T b)
{
 return a+b;
}

int main(void)
{
 cout<<Add(10,20)<<endl;  //한번 모형자로 펜을 잡고(함수를 시작한다) 도형을 그리기 시작하면 펜을 놓기전(함수종료)에는 다른 펜을 사용할수없다
 cout<<Add(1.1,2.2)<<endl; //펜을 바꾼다 ( 자료형을 바꾼다 )
 return 0;
}

*/


///////////////////////////////////////////////////////////////////////////////////////


//함수 템플릿!!

// "함수 템플릿" 이라고 부른다는 것은 템플릿임을 강조하는 것이다.(함수가 아니라는 뜻이 아니다).
// 함수이기 전에 템플릿의 정의해 해당된다는 것을 의미한다.

 


template <typename T1, typename T2> //이것은 한 함수에 펜을 2개 사용할수 있게 해준다!

void ShowData(T1 a, T2 b) 
{
 cout<<a<<endl;
 cout<<b<<endl;
}

int main(void)
{
 ShowData(1, 2);
 ShowData(3, 2.5);
 return 0;
}


////////////////////////////////////////////////////////////////////////////////////

//함수 템플릿 특수화 선언

 

#include <iostream>
using::std::endl;
using::std::cout;

template <typename T> //함수 템플릿 정의
int SizeOf(T a)
{
 return sizeof(a);
}
/*
                   다음과 같이 한 줄에 표현하는 것이 보통이다.

template<>    //함수 템플릿 특수화 선언       선언1:template<> int SizeOf(char *a)
                   선언2:template<> int SizeOf<>(char *a)
int SizeOf(char *a)  //전달 인자가 char *인 경우에는 이 함수를 호출  선언3:template<> int SizeOf<char*>(char *a)
{                   선언3의 형태가 가장 정확한 표현이고, 선언1과 2는 선언3을 줄여서 표현한
 return strlen(a);              형태이다. 그러므로 선언 3의 표현 방법도 기억하자!!!
}

*/
int main(void)
{
 int i=10;
 double e=7.7;
 char * str= "Good Morning!";

 cout<<SizeOf(i)<<endl;
 cout<<SizeOf(e)<<endl;
 cout<<SizeOf(str)<<endl;
 
 return 0;
}


////////////////////////////////////////////////////////////////////////////////////

 


template <typename T>
class Data      //클래스 템플릿도 선언과 정의를 분리하는 것이 가능하다.
{
 T data;

 public:

  Data(T d);
  void SetData(T d);
  T GetData();
};

template <typename T>
Data<T>::Data(T d)
{
 data = d;
}

template <typename T>
void Data<T>::SetData(T d) // Data<T> 이것은 T타입에 대해서 템플릿으로 정의되어 있는 "Data
{       // 클래스 템플릿"을 의미

       // Data::SetData 는 Data클래스의 멤버 함수를 정의하는 것이지
 data = d;    // "Data 클래스 템플릿"의 멤버 함수를 정의하는 것이 아니다.
}

template <typename T>
T Data<T>::GetData()
{
 return data;
}


////////////////////////////////////////////////////////////////////////////////////////


//스택 클래스의 템플릿화!!


template <typename T>
class Stack{
 private:
  int topidx;   // 마지막 입력된 위치의 인덱스
  T *stackPtr;  // 스택 포인터

 public:
  Stack(int s=10);
  ~Stack();
  void Push(const T& pushValue);
  T Pop();
};

template <typename T>
Stack<T>::Stack(int len)
{
 topIdx=-1;    // 스택 인덱스 초기화
 stackPtr=new T[len];
}

template <typename T>
Stack<T>::~Stack()
{
 delete[] stackPtr;
}

template <typename T>
void Stack<T>::Push(const T& pushValue)  // 스택에 데이터 입력
{
 stackPtr[++topIdx]=pushValue;
}

template <typename T>
T Stack<T>::Pop()    //스택에서 꺼냄
{
 return stackPtr[topIdx--];
}


int main()
{
 Stack<char> stack1(10);     // char형 데이터를 저장하기 위한 stack 객체를 생성!
 stack1.Push('A');
 stack2.Push('B');
 stack3.Push('C');

 for(int i=0; i<3; i++)
 {
  cout<<stack1.Pop()<<endl;
 }

 Stack<int> stack2(10);     // int형 데이터 저장을 위한 stack 객체를 생성!
 stack2.Push(10);
 stack2.Push(20);
 stack2.Push(30);

 for(int j=0; j<3; j++)
 {
  cout<<stack2.Pop()<<endl;
 }

 return 0;
}

// stack 클래스 처럼 템플릿화하면 , 하나의 자료형에 종속되지 않는다!
// 이런식으로 자주 사용되는 자료 구조와 알고림을 템플릿으로 정의해 놓으면, 여러모로 유용할 것이다!

 


///////////////////////////////////////////////////////////////////////////////////////////////////

//템플릿 함수 or 템플릿 클래스!!!


template <typename T>  //함수 템플릿 정의!
T Add(T a, T b)
{
 return a+b;
}

 

int main(void)
{
 cout<<Add(10,20)<<endl;    // 함수 템플릿의 T가 int로 해석되어서 호출되기를 바라고있다. 그러나 실제로는 컴파일러가 int형 함수를만든다. 그것을 호출한다.
 cout<<Add(1.1,2.2)<<endl;   // 위와 동일하고 Double형 함수를 만든다!
 cout<<Add(10,20)<<endl;    // 첫번째줄에서 만든 함수를 호출해온다!
 return 0;     

 // 이처럼 함수 템플릿을 기반으로 해서 만들어지는, 실제 호출이 가능한 함수들을 가리켜 템플릿 함수라고 부른다!
 // 또한 템플릿 함수가 생성되는 현상을 가리켜서 "함수 템플릿의 인스턴스화"라고 부른다!
}

'프로그래밍 기초 > C++' 카테고리의 다른 글

반올림함수 만들기  (0) 2010.05.11
가상함수테이블  (0) 2010.03.04
다형성  (0) 2010.03.04
This 포인터  (0) 2010.01.24
Posted by 아몰라
이전버튼 1 이전버튼