#클래스 템플릿(class template)

템플릿은 컴파일시 내부적으로 템플릿 인자로 넘어온 자료형을 적용하여 새로운 클래스를 하나 생성하게 된다. 그리고 컴파일러는 생성한 클래스를 가지고 작업을 수행하게 된다. 템플릿 클래스는 선언시 자료형에 상관없는 범용클래스로 만든후 객체 생성시 자료형을 지정해주면, 지정한 자료형에 맞는 클래스 인스턴스가 생성된다.

template <typename 식별자> 클래스 {  //클래스 정의

  //내용

};

template <typename 식별자>

void 클래스명<식별자>::멤버함수() {  // 맴버 함수 구현

  //내용

}


//***************************************************************************
// 템플릿 클래스 !!
//***************************************************************************


#include <iostream>
using namespace std;
// 배열 추상화 !!
// 1) 속성!!
// --> Data buffer !!
// --> 배열의 길이
// 2) 행동 !!
// --> 입력
// --> 삭제
// --> 출력
template <typename T>
class Array
{
private :
T *m_Buf;
int m_size;
public :
Array()
{
cout << "최대 배열의 크기 입력 ";
cin >> m_size;
m_Buf = new int[sizeof(T)]();
//memset(m_Buf,0,40);//******************//
 menu();
}
~Array(){}
int & operator[](int idx)
{
return m_Buf[idx];
}
void push_back()
{
if(m_Buf[m_size-1] !=0){
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)+4);
m_size = _msize(m_Buf)/sizeof(int);
cout << "맨뒤에 넣을 값을 입력 ";
cin >> m_Buf[m_size-1];
}
else{
cout << "맨뒤에 넣을 값을 입력 ";
cin >> m_Buf[m_size-1];
}
}
void pop_back()
{
m_Buf[m_size-1] = 0;
cout << "["<< m_size << "]" << "맨뒤에 배열의 값을 뿅~~~~~" << endl;
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)-4);
m_size = _msize(m_Buf)/sizeof(int);
}
void push_front()
{
if(m_Buf[0] !=0){
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)+4);
m_size = _msize(m_Buf)/sizeof(int);
m_Buf[m_size-1] = 0;
for(int i=m_size;i>0;i--){
m_Buf[i-1] = m_Buf[i-2];
}
cout << "맨앞에 넣을 값을 입력 ";
cin >> m_Buf[0];
}
else{
cout << "맨앞에 넣을 값을 입력 ";
cin >> m_Buf[0];
}
}

void pop_front()
{
//cout << "맨앞에 배열의 값을 뿅~~~~~" << endl;
for(int i=0;i<m_size;i++){
  m_Buf[i] = m_Buf[i+1]; 
}
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)-4);
m_size = _msize(m_Buf)/sizeof(int);
cout << "["<< 0 << "]" << "맨앞에 배열의 값을 뿅~~~~~" << endl;
}
void Add()
{
int num=0;
cout << "몇번째 ?? " <<endl;
cin >> num;
if(m_Buf[num-1] !=0){
m_Buf = (int *)realloc(m_Buf,_msize(m_Buf)+4);
m_size = _msize(m_Buf)/sizeof(int);
m_Buf[m_size-1] = 0;
for(int i=m_size;i>num-2;i--){
  m_Buf[i-1] = m_Buf[i-2]; 
}
cout<< "숫자 입력 ";
cin >> m_Buf[num-1];
}
else{
cout<< "숫자 입력 ";
cin >> m_Buf[num -1];
}
}
void Pop_Select()
{
}

void Show()
{
for(int i=0;i<m_size;i++){
cout <<" "<< "["<< m_Buf[i] <<"]" ;
}
cout << endl;
}
void ascending_selection_sort ()    // 오름차순
{
cout << " 오름 차순 "<< endl;
int i, j, min;
for ( i = 0; i < m_size-1; i++ )
{
for ( min = i+1, j = i+2; j < m_size; j++ )
if ( m_Buf[min] > m_Buf[j] ) min = j;
  if ( m_Buf[min] < m_Buf[i] ){
  int t = m_Buf[i]; m_Buf[i] = m_Buf[min]; m_Buf[min] = t; 
 }
}
  Show();
void descending_selection_sort ()    // 내림차순
{
cout << " 내림 차순 " << endl;
int i, j, max;
for ( i = 0; i <m_size-1; i++ )
{
for ( max = i+1, j = i+2; j < m_size; j++ )
if ( m_Buf[max] < m_Buf[j] ) max = j;
if ( m_Buf[max] > m_Buf[i] ) {
int t = m_Buf[i]; m_Buf[i] = m_Buf[max]; m_Buf[max] = t; 
}
}
Show();
}



int Modi()
{
int num=0;
system("cls");
cout << "[1] 배열추가" << endl;
cout << "[2] push_back" << endl;
cout << "[3] pop_back" << endl;
cout << "[4] push_front" << endl;
cout << "[5] pop_front" << endl;
cout << "[6] 배열사이꺼 뺴기 " << endl;
cout << "[7] show " << endl;
cout << "[8] 내림차순정렬" << endl;
cout << "[9] 오름차순정렬" << endl;
cout << "[0] 종 료" << endl;
cin >> num;

return num;
}
void menu()
{
int num=0;
while((num = Modi()) != 0)
{
switch(num)
case 1: Add(); break;
case 2:push_back(); break;
case 3:pop_back(); break;
case 4:push_front();break;
case 5:pop_front(); break;
case 6:Pop_Select(); break;
case 7:Show(); break;
case 8 :descending_selection_sort(); break;
case 9:ascending_selection_sort () ;break;
default : cout << "error" << endl;
}
system("PAUSE");
}
}
Array &operator ()(Array &ar)
{
//ar.Show();
return ar;
}
};

template <typename T>
ostream & operator <<(ostream & os, Array<T> &ar)
{
ar.Show();
return os;
}

 

// 단점
// 1) 정적인 배열의 크기 ==> 동적배열 !!
// 2) 인덱스를 통한 접근이 안됨 ==> 연산자 오버로딩 !!
// 3) 시작위치의 주소값을 같지 않는다 ==> 객체 출력자 구현 !!

void main()
{
Array<int> ar;
cout << ar << endl;
//ar.Show();
//ar.push_back();
}


'Programing > C++' 카테고리의 다른 글

스마트 포인터  (0) 2016.11.30
가상함수테이블  (0) 2016.11.30
템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
클래스  (0) 2016.11.30
구조체  (0) 2016.11.30
[C++]템플릿(Template) - 함수 템플릿, 클래스 템플릿, 템플릿의 특수화
//*****************************************************************************
// 템플릿 (template)
//*****************************************************************************
// 일반화 프로그래밍
// 하나의 함수혹은 클래스에서 여러가지 경우를 모두 처리하는 프로그래밍 기법!
// 여러가지 경우라 함은 로직은 같지만 타입 때문에 여러개로 정의해야 하는 경우 

#템플릿이란?

기능은 결정되어 있으나 자료형이 정해져 있지 않는 것을 템플릿 이라고 한다. 예을 들어 계산기 프로그램의 덧셈 함수를 만들때 해당 자료형에 맞는 함수를 오버로딩해야 한다. 하지만 템플릿으로 만든 함수는 그럴 필요가 없이 하나의 함수로 모두 사용이 가능하다.

 

#함수 템플릿(Function Template)

template <typename 식별자> 함수()  // 함수 앞에 사용. 식별자는 자료형을 의미하는 것으로 적용할 자료형에 사용하면 된다.

참고사항> typename을 class 로 대체 가능하다.  ex> template <class T>

ex>

template <typename T>  // 두줄로 해도 상관 없다.

T Add(T a, T b)

{

  return a+b;

}

  int  p = Add(1,3);  // int형 4을 반환 한다.

  int  p = Add<int>(1,3);  // 명시적으로 <자료형>을 같이 써주어도 된다. 위와 동일하게 동작한다.

  double q = Add(1.1,3.3);  // double형 4.4을 반환한다.

  CString str1 = "abcd", str2 = "EFGH", str;

  str = Add(str1, str2);  // CString형 "abcdEFGH"를 반환 한다.

 

위와 같이 자료형은 다르지만 하나의 함수로 이것을 가능하게 해주는 것이 템플릿이다. 물론 자료형이 같다고 되는 건 아니다. 예로 char*의 경우 포인터끼리 + 한다면 우리가 원하는 값이 나오지 않을 것이다. 이때 사용하는 것이 템플릿 특수화이다. CString 의 경우에는 + 연산자오버로딩이  되어있기 때문에 가능하다.


#include <iostream>
using namespace std;

template<class Any>
void Swap(Any &a,Any &b)
{
Any temp;
temp = a;
a = b;
b = temp;
}
template<class Any,class Any2>
void Swap(Any2 &a,Any &b)
{
Any2 temp;
temp = a;
a = b;
b = temp;
}
void main()
{
int x= 20,y=10;
cout << "befor int swap   " << "x =  " << x <<"  "<<"y =  "<< y << endl; 
Swap(x,y);
cout << "after int swap   " << "x =  " << x <<"  "<<"y =  "<< y << endl;
cout << endl;
char i = 'c',j='j';
cout << "befor char swap   " << "i =  " <<i << "  "<<"j =  "<< j << endl; 
Swap(i,j);
cout << "after char swap   " << "i =  " << i<<"  " <<"j =  "<< j << endl;
cout << endl;
double k=24.5,c=94.3;
cout << "befor double swap   " << "k =  " <<k << "  "<<"c =  "<< c << endl; 
Swap(k,c);
cout << "after double swap   " << "k =  " << k<<"  " <<"c =  "<< c << endl;
cout << endl;

double num1 =84.5;
int num2 = 50;
cout << "befor double swap   " << "num1 =  " <<num1 << "  "<<"num2 =  "<< num2 << endl; 
Swap(num1,num2);
cout << "after double swap   " << "num1 =  " << num1<<"  " <<"num2 =  "<< num2 << endl;
cout << endl;
}


'Programing > C++' 카테고리의 다른 글

가상함수테이블  (0) 2016.11.30
템플릿(Template) -클래스 템플릿, 템플릿의 특수화  (0) 2016.11.30
클래스  (0) 2016.11.30
구조체  (0) 2016.11.30
함수 오버로딩, SWAP  (0) 2016.11.30
#ifndef MYTIME
#define MYTIME
//****************************************************************************************
//클래스 선언
//****************************************************************************************
class Time
{
private:
int hours;
int min;
public:
Time();
Time(int h,int m = 0);
void AddMin(int m);
void AddHr(int h);
void Reset(int h = 0, int m =0);
Time operator+(const Time & t) const;
Time operator-(const Time & t) const;
Time operator*(const Time & t) const;
void Show() const;
}
#endif MYTIME

//****************************************************************************************
#include <iostream>
#include "ex2.h"

Time::Time()
{
Hours = minutes = 0;
}
Time ::Time(int h, int m )
{
hours =h;
min = m ;
}
void Time::AddMin(int m)
{
min += m;
hour += min/60;
mim %= 60;
}

void Time::AddHr(int h)
{
hours += h;
}

void Time::Reset(int h, int m)
{
hours = h;
min = m;
}

Time Time::operator +(const Time &t) const
{
Time sum;
sum.min = min +t.min;
sum.hours = hour + t.hours + sum.min / 60;
sum.min %= 60;
return sum;
}

Time Time::operator -(const Time &t) const
{
Time diff;
int tot1, tot2;
tot1 = t.min + 60 * t.hours;
tot2 = min + 60 * hours;

diff.min = (tot2 - tot1) % 60;
diff.hours = (tot2 - tot1) / 60;

return diff;
}

Time Time::operator *(const Time &t) const
{
Time result;
long totalmin = hours * mult * 60 + min * mult;
result.hours = totalmin / 60;
result.min = totalmin % 60;

return result;
}

void Time::Show() const
{
std::cout << hours << "시간," << min <<"분";
}
//****************************************************************************************
// main
#include <iostream>
#include "ex2.h"

void main()
{
using namespace std;

Time weeding(4, 35);
Time waxing(2,47);
Time total;
Time diff;
Time adjusted;

cout << "weeding time = ";
weeding.Show();
cout << endl;

cout << "waxing time =";
waxing.Show();
cout << endl;

cout << "total work time =";
total = weeding + waxing;
total.Show();
cout << endl;

diff = weeding - waxing;
cout << "weeding time - waxing time =";
diff.Show();
cout << endl;

adjusted = total * 1.5;
cout << "adjusted work time = ";
adjusted.Show();
cout << endl;
}


//**************************************************************************
//구조체 !!
//**************************************************************************
//정의 : 사용자 정의 데이터 타입 !!
//**************************************************************************
// 기본 타입으로 표현하기 힘든것들을 표현하기 위한 방법 !!
#include <iostream>
using namespace std;

class Person
{//속성
private :
int Number; // 번호
int age; // 나이
char name[20]; //이름
int stress; //스트레스
//행동
public :
int GetAge(){
return age;
}

char *GetName(){
return name;
}

void SetAge(int newage)
{
if(newage <= 0)
{
age = 1;
}
else
{
age = newage;
}
}

void speak(){
stress--;
}
void sleeping(){
stress--;
}
void play(){
stress--;
}
void fighting(){
}
void show(){
cout << Number << age << name << endl;
}

};
//접근 제한자!!
//private : 외부로부터 접근을 막는다.!!
//public : 내부 외부 모두에서 접근 할도록 지정 !!
//protected : 상속 : 외부에서는 접근할수 없고 오직 내부,자식에서만 접근 가능

void main()
{
Person LEE;
LEE.play();
int i =  0;
cin >> i;
LEE.SetAge(i);
cout << LEE.GetAge() << endl;
cout << LEE.GetName() << endl;

}


#include <iostream>

//1.
/* new , delete
#include <malloc.h>

using namespace std;

void main()
{
int *p3 = new int;

int *p1 = (int *)malloc(sizeof(int)*10); 
int *p2 = new int[10];
delete p3;
delete [] p2;
free(p1);
int *p1 = (int *)malloc(sizeof(int)*10); //일반화 프로그래밍 !! ->void *  
free(p1);
}*/


//2.
/*

//참조 변수(REF)   & 참조형 변수
//변수에 대한 또다른이름 --> 별명--> 알리아스
using namespace std;
//call by value
void SWAP(int x, int y)
{
int temp;
temp = x;
x = y;
y = temp;
}
//c언어 call by ref
void SWAP(int *x, int* y)
{
int temp;
temp = *x;
*x = *y;
*y = temp;
}
// 레퍼런스를 이용한 call by ref
void SWAP(int & x, int & y)
{
int temp = x;
x = y;
y = temp;
}

void main()
{
int x = 10;
int y = 20;
cout << x << "  " << y << endl;
SWAP(&x,&y);
cout << x << "  " << y << endl;
cout << x << "  " << y << endl;
SWAP(x,y);
cout << x << "  " << y << endl;

cout << x << "  " << y << endl;
SWAP(x,y);
cout << x << "  " << y << endl;

int LEE_TAE_WON = 100;
//참조형 변수는 선언과 동시에 참조가 되어야 한다.
int & p = LEE_TAE_WON;
cout << LEE_TAE_WON << endl;
cout <<  p << endl;

}
*/
/*
//3.함수 오버로딩 ( 다중정의 )
//정의 : 같은 이름의 함수가 매개변수의 갯수와 타입에 따라서 
//   서로 다른 함수로 인식 하는 것

using namespace std;
//함수 원형 선언
void print();
void print(int);
void print(int , int);

void main()
{
print();
}

void print()
{
cout << "printf()" << endl;
}
void print(int x)
{
cout <<"printf(int x)" << endl;
}
void print(int x, int y)
{
cout <<"printf(int x,int y)" << endl;
}
*/

/*
//4,디폴트 파라미터 

using namespace std;

void foo(int Snum = 100, int age =20, char *name = "홍길동") 
{
cout <<"학번은"<<Snum<< "나이는" << age<< "살"<< " 이름은 "<<  name << "입니다."<< endl;
}

void main()
{
foo();
}
*/
/*
//함수 오버로딩은 같은 로직의 함수가 매개변수의 타입에 따라 구현될경우사용
//
int plus(int x = 0, int y = 0)
{
return x+y;
}
double plus(float x = 0, float y = 0)
{
return double(x+y);
}
using namespace std;

void main()
{
cout << plus() << endl;
}
*/
/*
#include <malloc.h>
 //c++ 동적 메모리 사용!!
using namespace std;

void main()
{

int *p = (int *)malloc(sizeof(int)*10);

//재할당
p = (int *)realloc(p , _msize(p)*2);
cout <<  _msize(p) << endl;
free(p);

int *p2 = new int[10];
// int *p3 = &(*p2);
p2 = new int[_msize(p2)/sizeof(int)*2];
// memcpy(p3,p2,_msize(p2));
// p3 * 2;

cout << _msize(p2) << endl;
delete [] p2;
}
*/

using namespace std;

int *dong(int size_t=1, bool check_zero=0,int *q=0)
{
int *temp = new int[size_t];
if(check_zero)
{
memset(temp,0,_msize(temp));
}
if(q)
{
memcpy(temp,q,sizeof(int)*size_t);
delete [] q;
}
return temp;
}
void main()
{
int *p = new int[10];
p[0] = 5;
p[2] = 3;
p = dong(3,1,p);
cout << p[1] << endl;
cout << _msize(p) << endl;
}


#include <iostream>
//using namespace std;
//using namespace A;

int x=200;
namespace B
{
//using std::cout;
//using std::endl;
using namespace std;

inline void foo() //함수를 호출하는 곳에서 바로 실행하게 해줌. 메모리 할당 X,메모리 절약 실행속도 업
// 단점 함수에잇는 내용이 많아지면 
{
/*cout.operator << (10);
cout <<"1" << endl;
cout << 10 << 29 << "aa"<<'X'<<3.14<< endl;

int x;
cin >> x;
cout << x<< endl;
*/
//int x=100;
//cout << ::x << endl;
/*
float f = 3.14;
int x = int(f);

cout << x << endl;
*/
cout<<"XXXXXXXX"<<endl;
cout<<"XXXXXXXX"<<endl;
cout<<"XXXXXXXX"<<endl;
}
}
//태그가 타입으로 승격
//구조체 태그로부터 변수를 바로 선언할수 있다.

struct BOOK
{
int price;
int page;
};

void main()
{
//B::foo();
BOOK *p1 = (BOOK *)malloc(sizeof(BOOK)*10);

free(p1);
}

//함수 오버로딩
//구조체


#include <stdio.h>

#include <stdio.h>

#include <windows.h>

void main()

{

            

             int mainarray[100000] ;

             //루틴의속도측정을위해사용

             LARGE_INTEGER liCounter1, liCounter2, liFrequency;

    QueryPerformanceFrequency(&liFrequency);

    QueryPerformanceCounter(&liCounter1);

 

             //10000000000 번의for 루프

 

             for(int i=0; i <100000 ; i++)

             {                                      

                           mainarray[i] =0;

             }

              QueryPerformanceCounter(&liCounter2);

 

              //측정결과

    printf("c 언어수행시간= %f \n", (double)(liCounter2.QuadPart - liCounter1.QuadPart) / (double)liFrequency.QuadPart);

 

 

             //어셈블리루틴속도측정을위해사용

    QueryPerformanceFrequency(&liFrequency);

    QueryPerformanceCounter(&liCounter1);

 

             //어셈루틴번의루프         

             register int k;

             int mainarray2[100000] ;

             _asm{                              

                           mov         dword ptr [k],0

                           mov         eax,dword ptr [k]

                           mov         dword ptr mainarray2[eax*4],0

L1 : cmp         eax,99999

                           je loop_end

                            add         eax,1

                            mov         dword ptr [k],eax

                            mov         eax,dword ptr [k]

              mov         dword ptr mainarray2[eax*4],0

                            jmp L1

loop_end:

             }

    QueryPerformanceCounter(&liCounter2);

 

             //결과

    printf("어셈수행시간= %f \n", (double)(liCounter2.QuadPart - liCounter1.QuadPart) / (double)liFrequency.QuadPart);

}


우호호호 이렇게 중간에 뭔가 해줘야 어셈이 빠르시군요


'Programing > C' 카테고리의 다른 글

C언어 ,c++ 어셈블리 변환  (0) 2016.11.30
어셈블리와 c언어 속도 비교  (0) 2016.11.30
띄어쓰기까지 입력가능한 scanf  (0) 2016.11.30
데이터형  (0) 2016.11.30
반복문  (0) 2016.11.30

#include <stdio.h>

#include <stdio.h>

#include <windows.h>

void main()

{

            

             //루틴의속도측정을위해사용

             LARGE_INTEGER liCounter1, liCounter2, liFrequency;

    QueryPerformanceFrequency(&liFrequency);

    QueryPerformanceCounter(&liCounter1);

 

             //10000000000 번의for 루프

             for(int i=1000000000; i > 0; i--)

             {                                      

             }

              QueryPerformanceCounter(&liCounter2);

 

              //측정결과

    printf("c 언어수행시간= %f \n", (double)(liCounter2.QuadPart - liCounter1.QuadPart) / (double)liFrequency.QuadPart);

 

}


위의 코드를 어셈블리 언어로 변환하는 간단한 방법~



위와 같이 명령 프롬프트에 프로젝트 폴더로 이동하여 cl main.cpp /FAs 라는 명령어를 통해 어셈블리 언어로 변환이 가능하다.




명령어를 수행하면 위와같이 성공적으로 됬단다 라는 말이 나오는데 에러가 있는 부분은 어디어디 에러있으니 고치세요~ 라고 나온다




변환후 폴더에 들어가보면 main.exe, main.asm 이라는 2개의 파일과 object 파일이 생성되는데 뭐 exe파일은 실행이고 asm 파일이 우리가 원하는

어셈블리로 변환된 파일이 되겠다~




변환된 모습~아오 하나도모르겟다 ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ

빠염~


'Programing > C' 카테고리의 다른 글

어셈블리 c언어 속도측정결과  (0) 2016.11.30
어셈블리와 c언어 속도 비교  (0) 2016.11.30
띄어쓰기까지 입력가능한 scanf  (0) 2016.11.30
데이터형  (0) 2016.11.30
반복문  (0) 2016.11.30

#include <stdio.h>

#include <stdio.h>

#include <windows.h>


void main()

{

             //루틴의속도측정을위해사용

             LARGE_INTEGER liCounter1, liCounter2, liFrequency;

    QueryPerformanceFrequency(&liFrequency);

    QueryPerformanceCounter(&liCounter1);

 

             //10000000000 번의for 루프

             for(int i=10000000000; i > 0; i--)

             {                                      

             }

              QueryPerformanceCounter(&liCounter2);

 

              //측정결과

    printf("c 언어수행시간= %f \n", (double)(liCounter2.QuadPart - liCounter1.QuadPart) / (double)liFrequency.QuadPart);

 

 

             //어셈블리루틴속도측정을위해사용

    QueryPerformanceFrequency(&liFrequency);

    QueryPerformanceCounter(&liCounter1);

 

             //어셈루틴번의루프

      register int r1=0;

             _asm{                 

                           mov  r1, 10000000000;

                           L1 : cmp r1,0                     // r1 값을0과비교

                           je loop_end; // r1 0 일경우loop_end

                           dec r1; // 1을감소시키고다시저장

                           jmp L1;

loop_end:

             }           

    QueryPerformanceCounter(&liCounter2);

 

             //결과

    printf("어셈수행시간= %f \n", (double)(liCounter2.QuadPart - liCounter1.QuadPart) / (double)liFrequency.QuadPart);

}



'Programing > C' 카테고리의 다른 글

어셈블리 c언어 속도측정결과  (0) 2016.11.30
C언어 ,c++ 어셈블리 변환  (0) 2016.11.30
띄어쓰기까지 입력가능한 scanf  (0) 2016.11.30
데이터형  (0) 2016.11.30
반복문  (0) 2016.11.30
scanf 에서 띄어쓰기를 입력하세 해줍니다~

scanf("%[^\n]") 
여기서 ^는 여집합 입니다.
[] 전체 집합 입니다.

여기서 [^\n] 은 \n(개행)의 여집합 즉, 개행을 제외한 모든 집합을 뜻합니다. 
이말은 개행이 들어가기 전까지 입력을 받는다는 뜻입니다. 


#include <stdio.h>
void main()
{
char arr[40]={0,};
scanf("%[^\n]",arr);
int i=0;
for(i=0;i<40;i++){
printf("%c",arr[i]);
}
}




'Programing > C' 카테고리의 다른 글

C언어 ,c++ 어셈블리 변환  (0) 2016.11.30
어셈블리와 c언어 속도 비교  (0) 2016.11.30
데이터형  (0) 2016.11.30
반복문  (0) 2016.11.30
재귀함수사용한 덧셈  (0) 2016.11.30

+ Recent posts