…·─━☆ 무한코딩세계

#include "bubbleSort.h"

bubbleSort::bubbleSort(void)
{
}

bubbleSort::~bubbleSort(void)
{
}

int bubbleSort::startSort(int* arr_list, int size)
{
 int i, j, temp;
 for(i = 0 ; i < size ; i++){
  for(j = 0 ; j < size - 1 ; j++){
   if(arr_list[j] > arr_list[j+1])
   {
    temp = arr_list[j+1];
    arr_list[j+1] = arr_list[j];
    arr_list[j] = temp;
   }
  }
 }
 return 0;
}

int bubbleSort::fileopenTest()
{
 FILE* fileTest;
 FILE* fileOutput;
 int temp1, temp2, temp3;
 char c_temp1, c_temp2;

 fileTest = fopen("test1.txt", "rt");
 if(fileTest == NULL)
 {
  printf("file open error");
 }

 fileOutput = fopen("test2.txt", "wt");
 if(fileOutput == NULL)
 {
  printf("file open error2");
 }

 fscanf(fileTest, "%d\n", &temp1);
 printf("%d\n", temp1);

 for(int i = 0 ; i < 2 ; i++ )
 {
  fscanf(fileTest, "%c%c\n", &c_temp1, &c_temp2);
  fprintf(fileOutput, "(%c-%c)\n", c_temp1, c_temp2);
  fscanf(fileTest, "%d %d %d\n", &temp1, &temp2, &temp3);
  fprintf(fileOutput, "(%d)\n", temp1 + temp2 + temp3);
 }

 fclose(fileOutput);
 fclose(fileTest);

 return 0;
}

int main()
{
 int arr[10] = {123,456,2367,324,67,3213,545,12,4,997};
 bubbleSort sort;

 sort.startSort(arr, 10);

 for(int i = 0 ; i < 10 ; i++)
 {
  printf("%d ", arr[i] );
 }
 printf("\n");

 sort.fileopenTest();

 system("pause");
 return 0;
}

클래스간 Callback Sample Source

Callback.zip

보통 구조체를 통해 파일을 읽고 쓸 수 있는 것은 알 것이다.
fwrite(&somestruct, sizeof (somestruct), 1, fp);
형식으로 쓰면 되는데 만약 구조체가 포인터( char*타입의 문자열이나 다른 구조체를 가리키고 있는 포인터)
포함하고 있다면 파일내의 데이터는 단지 주소값만 저장되기 때문에
fread가 이루어진다 해도 주소값만 저장되지 주소값이 가르키고 있는 값은 저장되지 않는다.
밑의 코드 예를 보자.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define FILENAME1 "test1.txt"

typedef struct TmpData{

 int f;
 char arr[100];
 char* pArr;

}sTmpData;

typedef struct FileData{

 int a;
 int c;
 char b;
 sTmpData e;

}sData;

int WriteStFile(sData* in);
int ReadStFile(sData* out);

int main()
{
 sData WriteData = {2,33,'d'};
 sData ReadData;
 memset(&ReadData, 0, sizeof(ReadData) );

 // init WriteData
 WriteData.e.f = 100;
 strcpy( WriteData.e.arr, "aaa");
 WriteData.e.pArr = (char*)malloc( sizeof( WriteData.e.arr ) );
 strcpy( WriteData.e.pArr, "bbb");

 // Write File
 WriteStFile(&WriteData);

 // Read Structure Data from File
 ReadData.e.pArr = (char*)malloc( sizeof( WriteData.e.pArr ) );
 ReadStFile(&ReadData);

 // print
 printf("%d %d %c %d %s", ReadData.a, ReadData.c, ReadData.b, ReadData.e.f, ReadData.e.pArr);

 free( WriteData.e.pArr );
 
 system("pause");

 return 0;
}

int WriteStFile(sData *in)
{
 FILE* pFile = NULL;
 pFile = fopen( FILENAME1, "wb" );

 fwrite(in, sizeof(sData) , 1, pFile);

 fclose(pFile);

 return 0;
}

int ReadStFile(sData *out)
{
 FILE* pFile = NULL;
 pFile = fopen( FILENAME1, "rb" );

 fread(out, sizeof(sData) , 1, pFile);

 fclose(pFile);

 return 0;
}

실행은 하면 다음과 같은 결과가 뜬다.

표준(c90/c95)의 엄격한 해석에 따라 유용하게 사용할 수 있는 편범이 올바르지 않은 것으로 결론나자.
C99는 해당 편법을 정당하게 지원할 수 있는  flexible array member라는 기술을 새로 추가하였다.
즉 배열이 구조체나 공용체의 마지막 요소인 경우에 한해 선언 시에 그 크기를 명시하지 않고
나중에 할당받을 수 있도록 배려한 것이다. - 출처 : C언어 펀더멘탈 -

#include <stdio.h>
#include "stdlib.h"

struct A {
    int a;
    int b[];
};
   
int main()
{
    const int N = 10;
    int i;
   
    struct A* p = (A*)malloc(sizeof(struct A) + sizeof(int) * (N - 1));
   
    p->a = 100;
    for (i = 0; i < N; i++)
    {
        p->b[i] = i;
    }
       
    printf("%d %d %d\n", p->a, p->b[0], p->b[N-1]);
    for( int loop = 0 ; loop < N + 1 ; loop++ )
    {
           printf("%d %d\n", p->a, p->b[loop]);
    }   
    system("pause");
    //free(p);
   
    return 0;  
}   

표준화 이전의 비원형함수 정의 방법이다. 소괄호안에는 파라메터의 변수명이 나오고 아래 따로 선언이 된 방식이다. 만일 선언이 되지 않는 경우 자동으로 int로 간주하게 된다.

2)

extern int func();

여기서 짚고 갈 점은 ()는 매개변수가 없다는 것이 아니라 매개변수에 대한 검사를 수행하지 않는 다는 의미이다.
즉 비원형 함수이며 매개변수가 없음을 의미하는 원형 선언은

extern int func(void);

이다.

다시 정리하자면

func(10, 20); 
func(10); 

위의 두 함수는
extern int func()와 같은 함수를 뜻한다는 것이다.

<의문점>

옜날 형식의 함수와 요즘 함수를 섞어서 썼을 때

extern int func(float);

int func(x)
float x;
{ ...

이렇게 쓰면 에러가 나므로

extern int func(double);

또는

int func(float x) { ... }
 
요렇게 써야 할 것이다.
만일

extern int func();

int func(x)
float x;
{ ...

이렇게 쓴다면?? 안되남??

#include <iostream>
#include <stdlib.h>

using namespace std;

int func();
int func2();

int main(int argc, char** argv)
{
    int (*aa)();           // 1. 함수 포인터
    typedef int (*qq)();   // 2. 함수 포인터 정의 : int를 리턴하는 함수에 대한 포인터
    typedef int (*ee)[5];  // 3. 5개의 int형 데이터를 저장하는 배열의 포인터를 정의
    int arr[5] ={1,2,3,4};
    int (*arrs[2])();      // 4. 함수 포인터를 저장하는 포인터 배열
    typedef int(*arrs2[2])(); // 5. 함수포인터를 저장하는 포인터 배열의 정의
         
    qq ww;      // 2 변수 선언         
    aa = func;  // 1 주소대입
    aa();       // 1 실행
    ww = func;  // 2 주소대입
    ww();       // 2 실행
    ee rr;      // 3 변수 선언
    rr = &arr;  // 3 주소대입
    for(int i = 0 ; i < 5 ; i++)
    {
         cout<<(*rr)[i]<<endl;  
    }   
   
    arrs2 arrs1;      // 5
    arrs[0] = func;   // 4
    arrs[1] = func2;  // 4
    arrs1[0] = func;  // 5
    arrs1[1] = func2; // 5
   
    arrs[0]();        // 4
    arrs1[1]();       // 5
   
    system("pause");
    return 0;
}   

int func()
{
    cout<<"haha"<<endl;
    return 0;
}   

int func2()
{
    cout<<"hoho"<<endl;
    return 0;  
}   

아주 간단한 차이만 설명하겠습니다.

typedef char *String_t;
#define String_d char *

String_t s1, s2;
String_d s3, s4;

s1, s2, s3는 char*형이지만 s4는 char형입니다.

일반적으로 char *s3, s4와 같은 의미로 보고 생각하시면 됩니다.

typedef는 스코프 규칙을 잘 따르는 장점이 있고, 매크로는 #ifdef를 쓸 수 있다는 장점이 있습니다.
잘 판단해서 이용해야 겠죠? ㅎㅎ