소트 알고리즘

:: 버블 소트

void BubbleSort (int nArray[], int n)
{
 bool bFlag = true;

 int nFinalPos = 0, nLimit = 0, nBubbleKey = 0;

 nLimit = n - 1;

 while(bFlag)
 {
  bFlag = false;

  for(int i = 0 ; i < nLimit ; ++i)
  {
   if(nArray[i] > nArray[i + 1])
   {
    nBubbleKey = nArray[i];
    nArray[i] = nArray[i+1];
    nArray[i+1] = nBubbleKey;

    bFlag = true;
    nFinalPos = i;

   }
  }

  nLimit = nFinalPos;
 }
}

 

:: 퀵소트

void QuickSort(int nArray[], int nSize)
{
 if(nSize > 1)
 {
  int nStandard = nArray[nSize-1];
  int i = -1;
  int j = nSize-1;
  int nTemp = 0;

  while(true)
  {
   while(nArray[++i] < nStandard);
   while(nArray[--j] > nStandard);

   if(i >= j) break;

   nTemp = nArray[i];
   nArray[i] = nArray[j];
   nArray[j] = nTemp;
  }

  nTemp = nArray[i];
  nArray[i] = nArray[nSize-1];
  nArray[nSize-1] = nTemp;

  QuickSort(nArray, i);
  QuickSort(nArray + i + 1, nSize - i - 1);
 }
}

 

string handling

char *strcpy(char *dst, const char *src)
{
    char *cp = dst;
    while (*cp++ = *src++);
    return dst;
}

 

char *strncpy(char *dest, const char *source, size_t count)
{
    char *start = dest;

    while (count && (*dest++ = *source++)) count--;
    if (count) while (--count) *dest++ = '\0';
    return start;
}

 

char *strcat(char *dst, const char *src)
{
    char *cp = dst;
    while (*cp) cp++;
    while (*cp++ = *src++);
    return dst;
}

 

size_t strlen(const char * str)
{
  const char *s;
  for(s = str ; *s ; ++s);
  return (s - str);
}

 

size_t strlen(const char * str)
{
  const char *s = str;
  while(*s++);
  return s-str-1;
}

복사 생성자 and operator=

#include <iostream>
using namespace std;

class CA
{
public :
 int nA ;

 CA()
 {
  cout << "A 생성자 호출"<<endl;
 };

 CA(const CA & a)
 {
  cout<<"A 복사생성자 호출"<<endl;
 };

 CA& operator= (const CA &ca)
 {
  cout<<"A operator="<<endl;
  if ( this == &ca ) return (*this);
  nA = ca.nA;
 }
};

 

class CB : public CA
{
public :
 int nB ;
 CB():CA()
 {
  cout<<"B 생성자 호출"<<endl;
 };

 CB(const CB & b)
 {
  cout<<"B 복사생성자 호출"<<endl;
 };

 CB& operator= ( const CB &cb)
 {
  cout<<"B operator="<<endl;
  if ( this == &cb ) return (*this);
  nB = cb.nB;  
 }

};

 

int _tmain(int argc, _TCHAR* argv[])
{
 CB b; /// A생성자 > B생성자

 CB BB(b);  /// A생성자 > B복사생성자

 CB BBB = b; /// A생성자 > B복사생성자

 BB = b; /// operator =

 return 0;
}