
malloc

㭪            뤥 .

⠪          #include<stdlib.h>
                   #include<alloc.h>
                   void *malloc(size_t size);


, ᮤঠ騩   stdlib.h  alloc.h
⨯

ᠭ           㭪 ᯥ稢   뤥      ,
                   ࠧ஬   size   .      ணࠬ
                   뤥      室      ⮫쪮,
                   ᪮쪮 㦭.

                   ᪠         㯭     
                   ᪮  ࠧ饭   ६
                   .        ,   ⠪   
                   "ॢ"    "ᯨ᪨"  -  ⢥  ࠧ
                   ᯮ ᪮ । .

                      ,      
                   殬  ᥣ      設 ணࠬ
                   ⥪ 㯭  ᯮ짮,    ᪫祭
                   256-⮢ ࠭,  室饩 ।⢥
                   । 設 ⥪.  ࠭ ।祭
                     騢  ⥪ ਪ ணࠬ (
                   讥 ⢮, ॡ㥬  DOS).

                          ࠭⢮  ᫥
                   ணࠬ  ⥪      䨧᪮  
                   㯭  ᪮ .

頥       㭪 malloc 頥 㪠⥫   뤥-
祭            . ᫨  ࠧ饭  -
                   筮 ,  㭪  malloc  頥   NULL.
                   ন      ⠥   .   ᫨
                   㬥 size ࠢ 0,  㭪 頥 NULL.

७ᨬ      㭪 㯭  ⥬ UNIX  ন
                   ⠭⮬ ANSI C.

 ⠪     allocmem, calloc, coreleft, farcalloc, farmalloc,
                   free, realloc.


ਬ:

#include<stdio.h>
#include<string.h>
#include<alloc.h>
#include<process.h>

int main(void)
{
   char *str;
   /* 뤥   ப */
   if((str = malloc(10)) == NULL)
   {
      printf("筮 \n");
      exit(1); /* 襭   訡 */
   }
   /* ᪮஢  ப "Hello" */
   strcpy(str,"Hello");
   /* 뢥 ப */
   printf("ப: %s\n",str);
   /* ᢮  */
   free(str);
   return 0;
}


matherr

㭪            楤 ࠡ⪨ 訡  権    饩
                   窮, 㥬 짮⥫.

⠪          #include <math.h>
                   int matherr(struct exception *e);

, ᮤঠ騩   math.h
⨯

ᠭ           㭪 matherr  뢠   ࠡ⪨ 訡,
                   㥬     㭪ﬨ            ⥪
                   ⥬᪨ 㭪権.

                   matherr 㦨       ⢥    짮⥫᪮
                   誨,   (㭪樨   ।塞  짮⥫)
                       ᠬ (ᬮ ਬ).

                   matherr  ᯮ짮  ᫥ 訡
                    ।  室  । ,
                   ந室   ⥬᪨  㭪.    
                   ᫥  ᪫⥫ 権,  
                     ࠡ    祭ﬨ    饩   窮
                   (ਬ        0).   ᫥
                   ⠪ 訡 ᬮ 㭪 signal.

                       ஢    楤    matherr
                   ᯥ樠쭮    襣   (   㤥
                   ⫠     ।     ⨯     訡);
                   ஢ 㭪 matherr  
                   0,  ᫨    ࠡ  訡,  
                   1,  ᫨  訡 ᯥ譮 ࠡ⠭.  ᫨ 㭪
                   matherr 頥 㫥  祭,  ᮮ饭
                     訡    ⠥,   ६ errno 
                   .

                    ਢ  exception (। 
                   䠩 math.h):

                   struct exception {
                   int type;
                   char *Function;
                   double arg1, arg2, retval;
                   };

                   ⠢      exception  
                   ᫥饥:


                      

 type     ⨯ ந襤襩 ⥬᪮ 訡; ⨯ enum ।
           typedef_mexcep (ᬮ । ᫥  ᯨ-
          ).
 Function 㪠⥫  ᨬ ப  㫥 砭, -
          ঠ  筮 ⥬᪮ 㭪樨, 
          뤠 訡.
 arg1,    㬥 (।  㭪樨),  맢
 arg2     訡; ᫨ 㭪樨 । ⮫쪮  㬥, 
          ࠭  arg1.
 retval   ⠭⭮ 頥 祭  㭪樨 matherr;
            ஢  祭.


                   ࠬ typedef_mexcep,  ⠪   ।   
                   䠩 math.h,   ᫥騥 ᨬ᪨
                   ⠭,    ।⠢騥    ᮡ    
                   ⥬᪨ 訡:


 ᪠     ⥬᪠ 訡
 ⠭      

 DOMAIN          㬥  室   । 㭪樨
                 (ਬ log(-1));
 SING            㬥  訡  ᨭ୮ (ਬ
                 pow(0,-2));
 OVERFLOW        㬥 ਢ  १, ॢ饬
                 MAXDOUBLE (ਬ exp(1000));
 UNDERFLOW       㬥 ਢ  १, 襬
                 MINDOUBLE (ਬ exp(-1000));
 TLOSS           㬥  १  ३  
                 ਬ sin(10e70)).


                   ᪨ ⠭   MAXDOUBLE     MINDOUBLE
                   ।  䠩 values.h.

                   室   㭪樨 matherr,  । 
                   㬮砭  室    ਡ⨢  ᪠ 
                   ⥬ Borland C++.

                   ⠭ UNIX  㭪樨  matherr   ᮢ⨬   
                   ⠭⮬  ANSI  C.  ᫨    ॡ  
                   㭪樨  matherr    ⥬  UNIX,  
                   ணࠬ      matherr.c,     ⠢塞     
                   ਡ⨢ ᪥  Borland C++.

頥        㬮砭 㭪 matherr 頥 1 ᫨
祭           訡 UNDERFLOW  TLOSS,   0. 㭪
                   matherr ⠪      ஢    ࠬ
                   e->retval,    ।⢮  㭪樨  matherr
                   ।  뢠 ணࠬ.

                    㭪 matherr 頥  0,  (騩,
                     ࠡ  訡      ),  㭪
                   _matherr ⠭ ६ errno  ⠥
                   ᮮ饭      訡.
                   
                    㭪    matherr    頥   㫥
                   祭,   (饥,      訡    ᯥ譮
                   ࠡ⠭),   쭠   ६   errno  
                   ⠭      ᮮ饭      訡   
                   뢮.

७ᨬ      matherr 㯭    ,  
                     ন ⠭⮬ ANSI C. matherr 
                   ⨫ ⥬ UNIX ( ⠥  ᮮ襭  
                   蠥   믮   ணࠬ)   ⠢
                     ⮬ Borland C++    䠩  MATHERR.C.
                   matherr       ন    쭥
                    Borland C++.

ਬ:

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

int matherr(struct exception *a);
{
   if (a -> type == DOMAIN)
   {
      if(strcmp(a -> name, "sqrt") == 0)
      {
         a -> retval = sqrt (-(a -> arg1));
         return (1);
   }
}
return (0);
}

int main(void)
{
   double x,y;
   x = -2.0;
   y = sqrt(x);
   printf("祭, ᪮४஢ matherr: %lf\n",y);
   return 0;
}


max

㭪            頥 襥   祭.

⠪          #include<stdlib.h>
                   (type)max(a,b);

 ᮤঠ騩    stdlib.h
⨯

ᠭ            ப    ந    ࠢ   
                   祭     頥   襥      .
                     㭪樨      㬥  
                    ⨯.

頥       max 頥 襥   祭.
祭

 ⠪     min.

ਬ:

#include<stdlib.h>
int main(void)
{
  int x = 5;
  int y = 6;
  int z;
  z = max(x,y);
  printf("襥 祭: %d\n",z);
  return 0;
}

뢮:

襥 祭: 6


memccpy, _fmemccpy

㭪              ࠧ஬  n .

⠪          #include<mem.h>
                    near: void *memccpy(const void *dest,
                                 const void *src, int c, size_t n);

                    far:  void *_fmemccpy(const void *dest,
                                 const void *src, int c, size_t n);
                   
 ᮤঠ騩    mem.h, string.h

ᠭ           memccpy       n    src  dest.
                   ஢     ४頥          ᫥
                   ⥫⢠:

                   -   ᨬ c.

                   -  dest ᪮஢ n .

頥       memccpy 頥 㪠⥫  , ࠧ㦥 ᫥-
祭           騩  , ᫨   ᪮஢.  ⨢
                   砥 memccpy 頥 NULL.

७ᨬ      memccpy 㯭  UNIX System V.

 ⠪     memcpy, memmove, memset.

ਬ:

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

int main(void)
{
   char *src = "This is the source string";
   char dest[50];
   char *ptr;
   ptr = memccpy(dest,src,'c',strlen(src));
   if(ptr)
   {
      *ptr = '\0';
      printf("  ᨬ %s\n",dest);
   }
   else
      printf("  \n");
   return 0;
}


memchr,_fmemchr

㭪            ᬠਢ n   ᪠ ᨬ c.

⠪          #include<mem.h>
                    near: void *memchr(const void *s, int c,
                                 size_t n);
                   
                    far:  void *_fmemchr(const void *s, int c,
                                size_t n);

 ᮤঠ騩    mem.h, string.h

ᠭ           memchr ᬠਢ    ࠧ஬  n  ,  
                    㪠뢠 ࠬ s,  ᪠ ᨬ c.

頥        ᯥ譮 襭 memchr 頥 㪠⥫
祭             , ᮤঠ騩 ,  ⨢ 砥
                   memchr 頥 NULL.

७ᨬ      memchr 㯭  UNIX System V  ন
                   ⠭⮬ ANSI C.

ਬ:

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

int main(void)
{
   char *src = "This is a string";
   char *ptr;
   ptr = memchr(src,'r',strlen(src));
   if(ptr)
   {
      printf("  ᨬ 'r' 樨 %d\n",ptr-src);
   }
   else
      printf("  \n");
   return 0;
}


memcmp, _fmemcmp

㭪            ࠢ        n
                   .

⠪          #include<mem.h>
                    near: void *memcmp(const void *s1, const
                                 void *s2,size_t n);
                   
                    far:  void *_fmemcmp(const void *s1, const
                                 void *s2,size_t n);
                   
 ᮤঠ騩    mem.h,string.h
⨯

ᠭ           memcmp ࠢ  n   s1  s2,
                    祭 ⨯ unsigned char.

頥       memcmp 頥 祭:
祭
                   <0 - ᫨ s1  s2
                   =0 - ᫨ s1 ࠢ s2
                   >0 - ᫨ s1  s2

                   .. memcmp ந ࠢ 祭, 
                   ⨯ unsigned char,   ⠪ 맮:

                       memcmp("\xFF", "\x7F",1);

                   頥 祭 㤥 > 0.

७ᨬ      memcmp  㯭  UNIX System V  ন
                   ⠭⮬ ANSI C.

 ⠪     memccpy, memmove, memset, movedata, movemem.

ਬ:

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

int main(void)
{
   char *buf1 = "aaa";
   char *buf2 = "bbb";
   char *buf3 = "ccc";
   int stat;
   stat = memcmp(buf2,buf1,strlen(buf2));
   if(stat>0)
      printf("buf2 > buf1\n");
   else
      printf("buf2 < buf1\n");
   stat = memcmp(buf2,buf3,strlen(buf2));
   if(stat<0)
      printf("buf2 > buf3\n");
   else
      printf("buf2 < buf3\n");
   return 0;
}


memcpy, _fmemcpy

㭪               n .

⠪          #include<mem.h>
                    near: void *memcpy(void *dst,
                                 const void *src,size_t n);
                   
                    far:  void *memcpy(void *dst,
                                 const void *src,size_t n);

, ᮤঠ騩   string.h, mem.h
⨯

ᠭ           memcpy  n   src  dst.  ᫨  src  
                   dst    ४뢠,           㭪樨
                   ।.

頥       memcpy 頥 dst.
祭

७ᨬ      memcpy  㯭  UNIX System V  ন
                   ⠭⮬ ANSI C.

 ⠪     memccpy, memmove, memset, movedata, movemem.

ਬ:

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

int main(void)
{
   char src[] = "******************************";
   char dest[] = "abcdefghijklmnopqrstuvwxyz0123456789";
   char *ptr;
   printf("ப 祭 । ஢: %s",dest);
   ptr = memcpy(dest,src,strlen(len));
   if(ptr)
      printf("ப 祭 ᫥ ஢: %s",dest);
   else
     printf("訡 memcpy");
   return 0;
}


memicmp

㭪            ࠢ n         ᨢ    ᨬ,
                    ࠧ稥 ॣ஢.

⠪          #include<mem.h>
                    near: int memcmp(const void *s1,
                                  const void *s2, size_t n);
                                                  
                    far:  int memcmp(const void *s1,
                                  const void *s2, size_t n);
                   
 ᮤঠ騩    mem.h,string.h
⨯

ᠭ           memicmp ࠢ    n   s1  s2,
                    ࠧ ॣ஢ (孨  ).

頥       memicmp 頥 祭:
祭
                   <0 - ᫨ s1  s2
                   =0 - ᫨ s1 ࠢ s2
                   >0 - ᫨ s1  s2

७ᨬ      memicmp  㯭  UNIX System V.

 ⠪     memcmp.

ਬ:

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

int main(void)
{
   char *buf1 = "ABCDE123";
   char *buf2 = "abcde456";
   int stat;
   stat = memicmp(buf1,buf2,5);
   printf("ப  樨 5");
   if(stat)
      printf("");
   printf("ࠢ");
   return 0;
}


memmove

㭪              ࠧ஬  n .

⠪          #include<mem.h>
                   void *memmove(void *dest, const void *src,
                                      size_t n);

 ᮤঠ騩    mem.h,string.h
⨯

ᠭ           memmove    n     src    dest.
                   ஢  㤥  ந  ४⭮,  ,
                   ᫨  ४뢠.

頥       memmove 頥 dest.
祭

७ᨬ      memmove 㯭  UNIX System V  ন
                   ⠭⮬ ANSI C.

 ⠪     memccpy, memcpy, movmem.

ਬ:

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

int main(void)
{
   char src[] = "******************************";
   char dest[] = "abcdefghijklmnopqrstuvwxyz0123456789";
   printf("ப 祭 । ஢: %s",dest);
   ptr = memmove(dest,src,26);
   printf("ப 祭 ᫥ ஢: %s",dest);
   return 0;
}


memset, _fmemset

㭪              ࠧ஬  n  祭ﬨ c.

⠪          #include<mem.h>
                    near: void *memset(void *s, int c,
                                 size_t n);
                   
                    far:  void *_fmemset(void *s, int c,
                                 size_t n);
                   
 ᮤঠ騩    mem.h, string.h
⨯

ᠭ           memset ᢠ    n  ⠬  ᨢ   s
                   祭 c.

頥       memmove 頥 s.
祭

७ᨬ      memset 㯭  UNIX System V  ন
                   ⠭⮬ ANSI C.

 ⠪     memccpy, memcpy, setmem.

ਬ:

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

int main(void)
{
   char buffer[] = "Hello world\n";
   printf(" । ᯮ짮 㭪樨 memset:%s\n",buffer);
   memset(buffer,'*',strlen(buffer) - 1);
   printf(" ᫥ ᯮ짮 㭪樨 memset:%s\n",buffer);
   return 0;
}


min

㭪            頥 襥   祭.

⠪          #include<stdlib.h>
                   (type)min(a,b);

 ᮤঠ騩    stdlib.h
⨯

ᠭ           min ந    ࠢ       祭   
                   頥 襥  .   㭪樨  
                    㬥    ⨯.

頥       min 頥 襥   祭.
祭

 ⠪     max.

ਬ:

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

int main(void)
{
  int x = 5;
  int y = 6;
  printf("襥 祭: %d\n",min(x,y));
  return 0;
}

뢮:

襥 祭: 6


mkdir

㭪             ⠫.

⠪          #include<dir.h>
                   int mkdir(const char *path);

 ᮤঠ騩    dir.h
⨯

ᠭ           mkdir ᮧ  ⠫      
                   .

頥        ᯥ譮 襭 mkdir 頥 0. 
祭            訡 mkdir 頥 -1 
                   ᢠ 쭮 ६  errno    
                   ᫥ 祭:

                   EACCES -  饭.
                   ENOENT -  ⠪ 䠩  ⠫.

 ⠪     chdir, getcurdir, getcwd, rmdir.
                                                         
ਬ:

#include<stdio.h>
#include<conio.h>
#include<process.h>
#include<dir.h>

int main(void)
{
   int status;
   clrscr();
   status = mkdir("asdfjklm");
   (!status) ? (printf("⠫ ᮧ\n")) :
               (printf("  ᮧ ⠫\n"));
   getch();
   system("dir");
   getch();
   status = rmdir("asdfjklm");
   (!status) ? (printf("⠫ 㤠\n")) :
               (printf("  㤠 ⠫\n"));
   return 0;
}


MK_FP

㭪             "쭨"  㪠⥫.

⠪          #include<dos.h>
                   void far *MK_FP(unsigned seg, unsigned ofs);

, ᮤঠ騩   dos.h
⨯

ᠭ           MK_FP     ம।,   ஥   ᮧ
                   쭨  㪠⥫      ᥣ  (seg)  
                   ᬥ饭 (ofs).

頥       MK_FR 頥 "쭨" 㪠⥫.

७ᨬ      MK_FP 㭨쭠  Borland C++.

 ⠪     FP_OFF, FP_SEG, movedata, segread.

ਬ:

#include<dos.h>
#include<graphics.h>

int main(void)
{
   int gd,gm,i;
   unsigned int far *screen;
   getectgraph(&gd,&gm);
   if(gd == HERMONO)
      screen = MK_FP(0xB000,0);
   else
      screen = MK_FP(0xB800,0);
   for(i=0; i<26; i++)
      screen[i] = 0x0700+('a'+i);
   return 0;
}


mktemp

㭪             㭨쭮  䠩.

⠪          #include<dir.h>
                   char *mktemp(char *template);

, ᮤঠ騩   dir.h
⨯

ᠭ           㭪 mktemp   頥      ࠬ  template
                   㭨쭮  䠩  頥  template.

                   ࠬ template  ।⠢ ᮡ ப
                   ᨬ  㫥 砭    墮⮢묨
                   ᨬ  x.    6    X   
                   㭨쭮  ⠭  㪢      窠   ⠪
                   ࠧ,   㪢, 窠   㪢 䨪
                     १   䠩.

                      䠩  ᢠ  ᫥   ᬮ
                      ᪥, 稭   AA.AAA, 
                    㦥    ⮬  ଠ.

頥       ᫨ ࠬ template ४⭮ ନ஢,
祭           㭪 mktemp 頥  ᨬ쭮 ப
                   template.  ⨢ 砥  頥 .

७ᨬ      㭪 ন  ⥬ UNIX.

ਬ:

#include<dir.h>
#include<stdio.h>

int main(void)
{
   /* fname ।    䠩 */
   char *fname = "TXXXXXX", *ptr;
   ptr = mktemp(fname);
   printf("%s\n",ptr);
   return 0;
}


mktime

㭪            ८ࠧ ६  ୮ ६.

⠪          #include<time.h>
                   time_t mktime(struct tm *t);

, ᮤঠ騩   time.h
⨯

ᠭ           ८ࠧ ६      ,      
                   㪠뢠   ࠬ  t,    ୮  ६  
                   ଠ,  ᯮ㥬  㭪樥   time.   室
                   祭  tm_sec,  tm_min, tm_hour, tm_mday 
                   tm_mon  ࠭祭 , ਢ묨 
                   ᠭ  tm.  ᫨ 祭  室
                    㪠 ।,    ਢ  㦭
                   .  祭     tm_wday  tm_yday
                    ᫥ ਢ ⠫ 祭.

頥        ਨ.
祭

७ᨬ      mktime ন ⠭⮬ ANSI C.

 ⠪     localtime, strftime, time.

ਬ:

#include<stdio.h>
#include<time.h>

char *wday[] = {"ᥭ","쭨","୨",
                "।","⢥","⭨","㡡",
                "⥭"};

int main(void)
{
   struct tm time_check;
   int year,month,day;
   /*  宦  , 室 
      ,    */
   printf(":  ");
   scanf("%d",&year);
   printf(":  ");
   scanf("%d",&month);
   printf(":  ");
   scanf("%d",&day);
   /*     time_check */
   time_check.tm_year = year -1900;
   time_check.tm_mon = month - 1;
   time_check.tm_mday = day;
   time_check.tm_hour = 0;
   time_check.tm_min = 0;
   time_check.tm_sec = 0;
   time_check.tm_isdst = -1;
   /*   ⠢  맢 mktime */
   if(mktime(&time_check) == -1)
       time_check.tm_wday = 7;
   /* 뢥   */
   printf(" : %s\n",wday[time_check.tm_wday]);
   return 0;
}


modf

㭪            饯 ᫮ (double)  楫  ஡
                   .

⠪          #include<math.h>
                   double modf(double x, double *iptr)

, ᮤঠ騩   math.h
⨯

ᠭ           modf ࠧ  ᫮  ⨯  double    楫   
                   ஡ .    頥  ipart,  
                   ஡  頥.

頥       modf 頥 ஡  x.
祭
                                                                     
७ᨬ      modf 㭨쭠  DOS.
                   
 ⠪     fmod, ldexp.

ਬ:

#include<math.h>
#include<stdio.h>

int main(void)
{
   double fraction,integer;
   double number = 100000.567;
   fraction = modf(number,&integer);
   printf("  ஡  ᫠ %lf ࠢ %lf  %lf",
           number, integer, fraction);
   return 0;
}


movedata

㭪             n .

⠪          #include<mem.h>
                   void movedata(unsigned segsrc, unsigned offsrc,
                         unsigned segdst, unsigned offdst, size_t n);

, ᮤঠ騩   mem.h, string.h
⨯

ᠭ           㭪 movedata    n  ,    室
                          (segsrc:offsrc)              
                   (segdest:offdest).

                   㭪 믮   ६饭      ,
                   ᨬ   .

頥       .
祭

७ᨬ      movedata 㭨쭠  DOS.

 ⠪     FP_OFF, memcpy, MK_FP, movmem, segread.

ਬ:

#include <mem.h>

#define COLOR_BASE 0xB800
#define BUFFER_SIZE 80*25*2

char buf[BUFFER_SIZE];

/* ࠭ ᮤন  梥⭮ ᯫ   */
void save_color_screen(char near *buffer)
{
  movedata(COLOR_BASE, 0, _DS, (unsigned)buffer, BUFFER_SIZE);
}
int main(void)
{
   save_color_screen(buf);
   return 0;
}


moverel

㭪            ६頥 ⥪      (CP)     
                   ﭨ.

⠪          #include <graphics.h>
                   void far moverel(int dx,int dy);

, ᮤঠ騩   graphics.h
⨯

ᠭ           moverel ६頥  ⥪    (CP)    dx
                   祪      dy 祪   Y.

頥       .
祭

७ᨬ      㭪 㭨쭠  Borland  C++.    ࠡ⠥
                   ⮫쪮   IBM PC  ᮢ⨬  ,
                   ᭠饭 ᯫ묨 ࠬ, ন騬
                   ᪨  ०.  㭪      ᮢ⨬   
                   Windows.

 ⠪     moveto.

ਬ:

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
/*  ⮮। */
int graphdriver = DETECT, gmode, errorcode;
char msg[80];

/* 樠 䨪   ६ */
initgraph(&graphdriver,&gmode,"");

/* 祭 १ 樠樨 */
errorcode = graphresult();
if(errorcode != grOk)  /* ᫨ 訡 */
{
   printf("訡 :%s\n",grapherrormessage(errorcode));
   printf(" ⠭   \n");
   getch();
   exit(1);  /* 襭   訡 */
}
/* ६ ⥪  (CP)   (20,30) */
moveto(20,30);
/* ᮢ  */
putpixel(getx(),gety(),getmaxcolor());
/* ᮧ ப  ᮮ饭 */
sprintf(msg," (%d,%d)",getx(),gety());
outtextxy(20,30,msg);
/* ६ ⥪  ⭮⥫쭮
   ⥪饣  */
moverel(100,100);
/* ᮢ  */
putpixel(getx(),gety(),getmaxcolor());
/* ᮧ ப  ᮮ饭 */
sprintf(msg," (%d,%d)",getx(),gety());
outtext(msg);

/* ⪠ */
getch();
closegraph();
return 0;
}


movetext

㭪             ⥪  ࠭   אַ㣮쭨
                    㣮.

⠪          #include<conio.h>
                   int movetext(int left, int top,
                                int right, int bottom,
                                int destleft, int desttop);

 ᮤঠ騩    conio.h
⨯

ᠭ           movetext    ᮤন  אַ㣮쭨  
                   ࠭, ।塞 㬥⠬ left, top, right
                     bottom,      אַ㣮쭨,  騩 ⥦
                   ࠧ.   孨 㣮 ⮣  אַ㣮쭨
                   । ࠬࠬ destleft, desttop.

                    न        ᮫묨,    ..
                   न⠬  ⭮⥫쭮    孥  㣫
                   ࠭.   㤥  ᪮஢  ४⭮,  
                   ᫨ אַ㣮쭨 ४뢠.

                   movetext ࠡ⠥   ⥪⮢ ०  ந
                   ।⢥ 뢮  ࠭.

頥       movetext 頥 㫥 祭  砥
祭           ᯥ譮 襭.  訡 (ਬ, ᫨
                   㪠 न    ।  ࠭),
                   movetext 頥 0.

७ᨬ      movetext  ᯮ짮  ⥬ IBM PC 
                   ᮢ⨬      .  㭪    ᮢ⨬  
                   Windows.

 ⠪     gettext, puttext.

ਬ:

#include<conio.h>
#include<string.h>

int main(void)
{
   char *str = " ⮢ ப";
   clrscr();
   cputs(str);
   getch();
   movtext(1,1,strlen(str),2,10,10);
   getch();
   return 0;
}


moveto

㭪            ६頥 ⥪      (CP)        
                   न⠬ (x,y).

⠪          #include <graphics.h>
                   void far moveto(int x,int y);

, ᮤঠ騩   graphics.h
⨯

ᠭ           moveto ६頥 ⥪  (CP)   
                   न⠬ (x,y)  ⥪饩  ᬮ.

頥       .
祭

७ᨬ      㭪 㭨쭠  Borland  C++.    ࠡ⠥
                   ⮫쪮   IBM PC  ᮢ⨬  ,
                   ᭠饭 ᯫ묨 ࠬ, ন騬
                   ᪨  ०.  㭪      ᮢ⨬   
                   Windows.

 ⠪     moverel.

ਬ:

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

int main(void)
{
/*  ⮮। */
int graphdriver = DETECT, gmode, errorcode;
char msg[80];

/* 樠 䨪   ६ */
initgraph(&graphdriver,&gmode,"");

/* 祭 १ 樠樨 */
errorcode = graphresult();
if(errorcode != grOk)  /* ᫨ 訡 */
{
   printf("訡 :%s\n",grapherrormessage(errorcode));
   printf(" ⠭   \n");
   getch();
   exit(1);  /* 襭   訡 */
}
/* ६ ⥪  (CP)   (20,30) */
moveto(20,30);
/* ᮢ  */
putpixel(getx(),gety(),getmaxcolor());
/* ᮧ ப  ᮮ饭 */
sprintf(msg," (%d,%d)",getx(),gety());
outtextxy(20,30,msg);
/* ᮢ  ⭮⥫쭮 ⥪饩 樨 */
moveto(100,100);
/* ᮢ  */
putpixel(getx(),gety(),getmaxcolor());
/* ᮧ ப  ᮮ饭 */
sprintf(msg," (%d,%d)",getx(),gety());
outtext(msg);
/* ⪠ */
getch();
closegraph();
return 0;
}



movmem

㭪             ,  length .

⠪          #include<mem.h>
                   void movmem(void *src, void *dest,
                    unsigned length);

, ᮤঠ騩   mem.h
⨯

ᠭ           㭪 movmem    length   
                   室   src   dest.  ࠢ
                   ஢ ᥣ 롨ࠥ ⠪  ࠧ,  
                     ᥣ   筮,   ᫨ 
                   ४뢠.

頥       .
祭

७ᨬ      movmem 㭨쭠  Borland C++.

 ⠪     memcpy, memmove, movedata.

ਬ:

#include<mem.h>
#include<alloc.h>
#include<stdio.h>
#include<string.h>

int main(void)
{
   char *source = "Borland International";
   char *destination;
   int length;
   length = strlen(source);
   destination = malloc(length+1);
   movmem(source,destination,length);
   printf("%s\n",destination);
   return 0;
}
