'프로그래밍 기초/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.05.11
가상함수테이블  (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
다형성  (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
다형성  (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
This 포인터  (0) 2010.01.24
템플릿이란!?  (0) 2009.11.20
Posted by 아몰라
TAG C++, 포인터

댓글을 달아 주세요


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

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

#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
템플릿이란!?  (0) 2009.11.20
Posted by 아몰라
TAG C++

댓글을 달아 주세요

이전버튼 1 이전버튼