C 언어 간이 텍스트 편집기 구현

이 프로그램 은 간단 한 텍스트 편집 기 를 완성 해 야 합 니 다.텍스트 의 입력,편집,삭제,검색 을 완성 하고 파일 의 접근 을 완성 할 수 있 습 니 다.
텍스트 편집 소프트웨어 에서 사용자 가 입력 한 모든 텍스트 내용 을 문자열 로 합 니 다.각종 텍스트 편집 소프트웨어 의 기능 은 강약 차이 가 있 지만 기본 동작 은 문자열 의 입력,수정,삭제(전체 줄 삭제 와 한 줄 의 하위 문자열 삭제 포함),검색,출력 등 을 포함한다.분석 을 통 해 시스템 은 다음 과 같은 기능 을 포함해 야 한다.
1.간단 한 텍스트 나 그래 픽 메뉴 인터페이스 가 있 음
2.문자열 이나 텍스트 블록의 찾기,교체,삭제,삽입,이동 작업 을 실현 할 수 있 습 니 다.
3.텍스트 파일 의 메모리 와 읽 기 기능 을 실현 할 수 있 습 니 다.
4.우호 적 인 인터페이스 와 강 한 용 착 력 을 가진다.
디자인 아이디어
1.사용 하 는 논리 구조
텍스트 편집 기 는 주로 텍스트 를 편집 하 는데 텍스트 의 조작 은 문자 에 대한 조작 이다.텍스트 편집 기 는 줄,열 두 방향 으로 편집 할 수 있 습 니 다.
모든 줄 은 하나의 선형 표 로 볼 수 있 고 선형 표 는 선형 구조 이 며 선형 구조의 특징 은 데이터 요소 간 에 선형 관계 이 고 데이터 요소 가'하나씩 배열'하 는 것 이다.하나의 선형 표 에서 데이터 요소 의 유형 은 같다.각 줄 에 저장 할 수 있 는 최대 글자 수 는 같 기 때문에 줄 방향 모든 선형 표 의 최대 길 이 는 똑 같이 설정 할 수 있다.행 과 행 간 의 관계 도 하나의 선형 표 로 볼 수 있다.
2.사용 하 는 저장 구조
선형 표 의 저장 소 는 두 가지 로 나 뉜 다.순서 저장 소 와 체인 저장 소 이다.
순서 저장 이란 메모리 에 주소 로 연속 되 는 저장 공간 순서 로 선형 표를 저장 하 는 각 요 소 를 말 하 는데 이런 저장 형식 으로 저장 되 는 선형 표를 순서 표 라 고 한다.프로 그래 밍 언어 에서 1 차원 배열 이 메모리 에서 차지 하 는 저장 공간 은 연속 적 인 저장 구역 이기 때문에 1 차원 배열 로 순서 표 의 데이터 저장 구역 을 표시 하 는 것 이 가장 적합 하 다.
체인 식 저장 소 는-그룹의 임의의 저장 소 를 통 해 선형 표 의 데이터 요 소 를 저장 하 는 것 이다.데이터 원 계 간 의 선형 관 계 를 구축 하기 위해 모든 데이터 요 소 는 데이터 요소 자체 의 정 보 를 저장 하 는 것 을 제외 하고 그 후계 나 전구 가 있 는 저장 소의 주 소 를 함께 저장 해 야 한다.이 두 부분의 정 보 는 하나의'결점'을 구성 하고 모든 요 소 는 이와 같다.데이터 요소 정 보 를 저장 하 는 것 을 데이터 필드 라 고 하고 전구 나 후계 주 소 를 저장 하 는 것 을 포인터 필드 라 고 합 니 다.하나의 저장 장치 주소 만 있 는 것 은 단일 체인 표 이 고 두 개의 저장 장치 주 소 는 더 블 링크 이다.
실제 기능 수 요 를 고려 하여 각 줄 의 선형 표 는 순서대로 저장 할 수 있 고 모든 문 자 는 하나의 노드 이다.이 줄 이 입력 할 수 있 는 최대 문 자 를 배열 의 길이 로 표시 합 니 다.줄 과 줄 사이 의 선형 표 는 더 블 링크 로 저장 합 니 다.각 노드 는 네 개의 구역 을 포함 하고 하나의 포인터 도 메 인 prior 는 이전 줄 을 가리 키 며 하나의 포인터 도 메 인 next 는 다음 줄 을 가리 키 고 하나의 데이터 도 메 인 num 은 줄 번호 이 며 하나의 데이터 도 메 인 은 본 줄 의 문자 배열 입 니 다.프로그램 은 줄 과 열 로 텍스트 위 치 를 표시 하고 줄 은 양 방향 링크 로 줄 정 보 를 저장 하 며 배열 아래 에 표 시 된 표지 열 정 보 를 사용 하여 문자 위 치 를 정확하게 찾 은 다음 에 검색,교체,삽입,블록 이동,삭제 등 여러 가지 조작 을 할 수 있다.

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX_LEN 100
#define NOT_FOUND -1
//      ：
struct line
{
 char text[MAX_LEN];  //    
 int num;  //  
 struct line *next; //         
 struct line *prior; //         
};
int lnum;
struct line *start;     //            
struct line *last;     //             
struct line *find(int);    //         
void patchup(int, int);    //             1 
void delete_text(int);     //      
void list();   //         
void save();   //    
void load();   //    ，      
void insert(char str[], int linenum, int position); //          
void printline(int linenum);   //      
void deletestr(int linenum, int position, int lenth); //       
int findstr(char * to_find);  //     
int menu_select();        //     
int menu_select_insert();//         
int menu_select_delete();//         
int menu_select_print(); //         
int menu_select_move();  //         
void enter(int linenum); //      
void enter_empty(int linenum); //       
//          ，       ，           、  、   、          。
int main(void)
{
 char str[MAX_LEN];
 int choice;
 int linenum = 1;
 int number = 0;
 start = NULL;
 last = NULL;
 load(); //    ，      
 do{
  choice = menu_select();
  switch (choice)
  {
  case 1:  //       
   choice = menu_select_insert();//       
   switch (choice)
   {
   case 1:   //    
    printf("\t  :");
    scanf("%d", &linenum);
    enter(linenum);
    break;
   case 2:  //          
    printf("         ：");
    scanf("%d", &linenum);
    printf("      -  ：");
    scanf("%d", &number);
    printf("       ：");
    scanf("%s", str);
    insert(str, linenum, number);
    break;
 
   case 3:   //    
    break;
   }
   break;
  case 2:   //      
   choice = menu_select_delete();  //      
   switch (choice)
   {
   case 1:   //     
    printf("\t  :");
    scanf("%d", &linenum);
    break;
   case 2:   //        
    printf("       ：");
    scanf("%s", str);
    number = findstr(str);
    if (number == NOT_FOUND)
     printf("    ");
    else
     deletestr(lnum, number, strlen(str));
    break;
   case 3:  //    
    break;
   }
   break;
  case 3:   //      
   choice = menu_select_print(); //     
   switch (choice)  //     
   {
   case 1:
    printf("\t  :");
    scanf("%d", &linenum);
    printline(linenum);
    break;
   case 2:  //    
    list();
    break;
   case 3:  //    
    break;
   }
   break;
  case 4:   //      
   printf("          ：");
   scanf("%s", str);
   number = findstr(str);
   if (number == NOT_FOUND)
    printf("    ");
   else
    printf("           :%d，  :%d
", lnum, number + 1);
   break;
  case 5:  //      
   printf("         ：");
   scanf("%s", str);
   number = findstr(str);
   if (number == NOT_FOUND)
    printf("    ");
   else
   {
    deletestr(lnum, number, strlen(str));
    printf("       ：");
    scanf("%s", str);
    insert(str, lnum, number + 1);
   }
   break;
 
  case 6:     //      
   choice = menu_select_move();   //     
   switch (choice)
   {
   case 1:   //       
    printf("             ：");
    scanf("%d", &linenum);
    enter_empty(linenum);
    break;
   case 2:   //      
    printf("             ：");
    scanf("%d", &linenum);
    delete_text(linenum - 1);
    break;
   case 3:   //      
    printf("             ：");
    scanf("%d", &linenum);
    printf("             ：");
    scanf("%d", &number);
    str[0] = ' ';
    str[1] = '\0';
    insert(str, linenum, number);
    break;
   case 4:   //    
    printf("             ：");
    scanf("%d", &linenum);
    printf("             ：");
    scanf("%d", &number);
    if (number <= 0)
     printf("     ");
    else
     deletestr(linenum, number - 2, 1);
    break;
   case 5:   //    
    break;
   }
   break;
  case 7:  //      
   save();
   break;
  case 8:  //        
   load();
   break;
  case 9:  //      
   exit(0);
   break;
  }
 } while (1);
 return 0;
}
//               ，            
int menu_select()
{
 int c;
 printf("
\t\t1.  
");
 printf("\t\t2.  
");
 printf("\t\t3.  
");
 printf("\t\t4.  
");
 printf("\t\t5.  
");
 printf("\t\t6.  
");
 printf("\t\t7.    
");
 printf("\t\t8.    
");
 printf("\t\t9.  
");
 do
 {
  printf("

\t\t      ：");
  scanf("%d", &c);
 } while (!(c >= 1 && c <= 9));
 return(c);
}
 
//                 ，                 。
int menu_select_insert()
{
 int c;
 printf("
\t\t1.      
");
 printf("\t\t2.      
");
 printf("\t\t3.      
");
 do{
  printf("

\t\t      ：");
  scanf("%d", &c);
 } while (!(c >= 1 && c <= 3));
 return(c);
}
//                 ，                  。
int menu_select_delete()
{
 int c;
 printf("
\t\t1.      
");
 printf("\t\t2.      
");
 printf("\t\t3.      
");
 do{
  printf("

\t\t      ：");
  scanf("%d", &c);
 } while (!(c >= 1 && c <= 3));
 return(c);
}
//                 ，                  
int menu_select_print()
{
 int c;
 printf("
\t\t1.    
");
 printf("\t\t2.    
");
 printf("\t\t3.      
");
 do{
  printf("

\t\t      ：");
  scanf("%d", &c);
 }while(!(c >= 1 && c <= 3));
 return(c);
}
//                 ，                  
int menu_select_move()
{
 int c;
 printf("
\t\t1.      
");
 printf("\t\t2.      
");
 printf("\t\t3.      
");
 printf("\t\t4.      
");
 printf("\t\t5.      
");
 do{
  printf("

\t\t      ：");
  scanf("%d", &c);
 } while (!(c >= 1 && c <= 5));
 return(c);
}
//               linenum       。
void enter(int linenum)
{
 struct line * info, * q, * p;
 p = start;
 q = NULL;
 while (p && p->num != linenum) //     
 {
  q = p;
  p = p->next;
 }
 if (p == NULL && (q->num + 1) != linenum) //      ，    
 {
  printf("        ");
 }
 else //      ，    
 {
  info = (struct line *)malloc(sizeof(struct line));
  printf("         ");
  scanf("%s", info->text);
  info->num = linenum;
  if (linenum == 1)  //      
  {
   info->next = p;
   p->prior = info;
   info->prior = NULL;
   start = info;
  }
  else if (q->num != linenum)  //       
  {
   q->next = info;
   info->next = p;
   info->prior = q;
  }
  else     //      
  {
   q->next = info;
   info->next = p;
   p->prior = info;
   info->prior = q;
  }
  while (p)   //           ，          1
  {
   p->num = p->num + 1;
   p = p->next;
  }
 }
}
 
//                   ，                 
//             1，    ，             1.
void patchup(int n, int incr)
{
 struct line *i;
 i = find(n);
 i = i->next;
 while (i)
 {
  i->num = i->num + incr;
  i = i->next;
 }
}
//                    。
void enter_empty(int linenum)
{
 struct line *info, *p;
 info = (struct line *)malloc(sizeof(struct line));
 if (!info)
 {
  printf("\t！    ！
");
  exit(0);
 }
 info->text[0] = ' ';
 info->text[1] = '\0';
 info->num = linenum;
 if (find(linenum))    //          ，     
 {
  p = start;
  if (linenum == 1)    //     
  {
   info->next = p;
   start = info;
   info->prior = NULL;
   p->prior = info;
  }
  else  //      
  {
   while (p->next->num != linenum)
    p = p->next;
   info->next = p->next;
   p->next->prior = info;
   p->next = info;
   info->prior = p;
  }
  patchup(linenum, 1);
 }
 else
  printf("     ");
}
 
//                  。                ，     
void insert(char str[], int linenum, int position)
{
 struct line * info;
 int len, i;
 int lenth;
 char rest_str[MAX_LEN], nostr[2] = { " " };
 info = start;
 while (info && info->num != linenum)   //       
 {
  info = info->next;
 }
 if (info == NULL)
  printf("     ！
");
 else if (position < 0)
  printf("     ！
");
 else    //        ，     
 {
  lenth = strlen(info->text);
  if (lenth < position) //           
  {
   len = position - lenth - 1;
   for (i = 0; i < len; i++)
    strcat(info->text, nostr);   //           
   strcat(info->text, str);    //         
  }
  else   //           
  {
   strcpy(rest_str, &info->text[position - 1]);
   strcpy(&info->text[position - 1], str);
   strcat(info->text, rest_str);
  }
 }
}
 
//             、    、    lenth     。
void deletestr(int linenum, int position, int lenth)
{
 struct line * info;
 char rest_str[MAX_LEN];
 info = find(linenum);
 if (info == NULL)
  printf("      ！n");
 else
 {
  if (strlen(info->text) <= (position + lenth))  //       <=      +    ，         '\0'
   info->text[position] = '\0';
  else
  {
   strcpy(rest_str, &info->text[position + lenth]);
   strcpy(&info->text[position], rest_str);
  }
 }
}
//               lineup   。
void delete_text(int linenum)
{
 struct line * info, *p;
 info = start;
 while ((info->num < linenum) && info)
  info = info->next;
 if (info->next == NULL)
  printf("     ");
 else
 {
  p = info->next;
  if (start == info) //         
  {
   start = info->next;
   if (start)  //     ，   
    start->prior = NULL;
   else  //     
    last = NULL;
  }
  else
  {
   info->prior->next = info->next;  //                
   if (info != last) //        
    info->next->prior = info->prior;  //              
   else  //       ，     
    last = info->prior;
  }
  free(info);
  while (p)
  {
   p->num = p->num - 1;
   p = p->next;
  }
 }
}
//              。
int findstr(char * to_find)
{
 struct line * info;
 int i = 0, find_len, found = 0, position;
 char substring[MAX_LEN];
 info = start;
 lnum = 0;  //      
 find_len = strlen(to_find);
 while (info && !found)   //  
 {
  i = 0;  //    
  while (!found && (i <= strlen(info->text) - find_len))  //      
  {
   strcpy(substring, &info->text[i], find_len);
   substring[find_len] = '\0';
   if (strcmp(substring, to_find) == 0)
   {
    found = 1;
    lnum = info->num;
   }
   else
    ++i;
  }
  info = info->next;
 }
 if (found)  //    
  position = i;
 else   //     
  position = NOT_FOUND;
 return(position);
}
//             ，                。
struct line * find(int linenum)
{
 struct line * info;
 info = start;
 while (info)
 {
  if (linenum != info->num)
   info = info->next;
  else
   break;
 }
 return (info);
}
 
//             
void printline(int linenum)
{
 struct line *info;
 info = find(linenum);
 if (info)
  printf("%d:%s
", info->num, info->text);
 else
  printf("     ");
}
//                   
void list()
{
 struct line * info;
 info = start;
 while (info)
 {
  printf("%d:%s
", info->num, info->text);
  info = info->next;
 }
 printf("

");
}
//                        
void save()
{
 struct line * info;
 char * p;
 FILE * fp;
 if ((fp = fopen("D:\\text.txt", "w")) == NULL){
  printf("\t     ！n");
  exit(0);
 }
 printf("\t      ！
");
 info = start;
 while (info)
 {
  p = info->text;
  while (*p)
   putc(*p++, fp);
  putc('
', fp);
  info = info->next;
 }
 fclose(fp);
}
//                        。
void load()
{
 struct line *info, *temp;  //info     ，temp  info    
 char c;
 FILE *fp;  //    
 int inct, i;  //    
 temp = NULL;
 if ((fp = fopen("D:\\text.txt", "r")) == NULL)
 {
  printf("\t     ！
");
  exit(0);
 }
 printf("
\t     ！
");
 start = (struct line*)malloc(sizeof(struct line)); //           
 info = start;
 inct = 1;
 while ((c = fgetc(fp)) != EOF)
 {
  i = 0;
  info->text[i] = c;
  i++;
  while ((c = fgetc(fp)) != '
')  //               ，       
    
  {
   info->text[i] = c;
   i++;
  }
  info->text[i] = '\0';  //             
  info->num = inct++;  //        1
  info->next = (struct line*)malloc(sizeof(struct line));
  if (!info->next)
  {
   printf("
\t      ！");
   exit(0);
  }
  info->prior = temp;
  temp = info;
  info = info->next;
 }
 temp->next = NULL;
 last = temp;
 free(info);
 start->prior = NULL;
 fclose(fp);
}

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.