
ecvt

㭪            ८ࠧ ᫮  饩 窮  ப
                   ᨬ.

⠪          #include<stdlib.h>
                   char * ecvt(double value, int ndig, int *dec,
                   int * sign);

, ᮤঠ騩   stdlib.h
⨯

ᠭ           㭪 ecvt  ८ࠧ 祭 value  ப 
                   㫥 砭  ndig ,  稭    ᠬ
                    饩   ,      頥   
                   㪠⥫   ப.      筮    窨
                   ⭮⥫쭮   砫   ப   ᢥ  ࠧ
                   ࠭  ࠬ decpt (⥫쭮  祭
                   decpt  砥     祭 ).  
                   ᠬ ப  筮  窨  .   ᫨   
                   १   ⥫,   ᫮,      ஥
                   㪠뢠   㪠⥫  sign,    ࠢ  0,
                     ࠢ 0. 訥 ࠧ 㣫.

頥       㭪 ecvt 頥  㪠⥫ 
祭            ப,  ᮤন १뢠
                     맮 㭪権.

७ᨬ      㭪 ন   ⥬  UNIX.    
                   ।    ⠤  ANSI  C,    ⮬  
                   ४㥬   ᯮ짮           ᠭ
                   ७ᨬ ணࠬ.

 ⠪     fcvt, gcvt, sprintf.

ਬ:

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

int main(void)
{
   char *string;
   double value;
   int dec, sign;
   int ndig = 10;

   value = 9.876;
   string = ecvt(value,ndig,&dec,&sign);
   printf("ப = %s      dec = %d sign = %d\n",string,dec,sign);
   value = -123.45;
   ndig = 15;
   string = ecvt(value,ndig,&dec,&sign);
   printf("ப = %s      dec = %d sign = %d\n",string,dec,sign);
   value = 0.6789e5;
   ndig = 5;
   string = ecvt(value,ndig,&dec,&sign);
   printf("ப = %s      dec = %d sign = %d\n",string,dec,sign);
   return 0;
}


ellipse

㭪              .

⠪          #include <graphics.h>
                   void far  ellipse (int x,int y,int stangle,
                                       int endangle,int xradius
                                       int yradius);

, ᮤঠ騩   graphics.h
⨯

ᠭ
                   ellpise     業஬  窥
                    न⠬ (x,y), ਧ⠫쭮  ⨪쭮
                   ﬨ ࠤᮬ xradius    yradius  ᮮ⢥⢥,
                   ⥪騬  梥⮬.  㣠    㣫 stangle 
                   㣫 endangle.  ᫨ stangle  ࠢ  0    endangle
                   ࠢ 360, 㭪 arc   .

                      arc 뢠 ⨢ ᮢ ५,
                    0 ࠤᮢ ᮮ⢥ 3 ᠬ  ࡫,
                   90 ࠤᮢ - 12 ᠬ  ..

                   砭. ࠬ    linestyle        뢠
                   ⢨     ஥   ,   㦭⥩,
                   ᮢ   ᥪ஢.  ᯮ  ⮫쪮 ࠬ
                   thickness.

頥       .
祭

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

 ⠪     arc, circle, fillellipse, getaspctratio, sector,
                   setaspectratio.

ਬ:

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

int main(void)
{
/*  ⮮। */
int graphdriver = DETECT, gmode, errorcode;
int midx,midy;
int stangle = 0,endangle = 360;
int xradius = 100,yradius = 50;

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

/* 祭 १ 樠樨 */
errorcode = graphresult();
if(errorcode != grOk)  /* ᫨ 訡 */
{
   printf("訡 :%s\n",grapherrormessage(errorcode));
   printf(" ⠭   \n");
   getch();
   exit(1);  /* 襭   訡 */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor(1));

/*   */
ellipse(midx,midy,stangle,endangle,xradius,yradius);

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


__emit__

㭪            ⠢ 祭 ࠫ ।⢥  .

⠪          #include<dos.h>
                   void __emit__(argument,...);

, ᮤঠ騩   dos.h
⨯

ᠭ           㭪 __emit__      ⠢ 祭
                   ࠫ ।⢥  ꥪ ,   ᫨
                         ⪮஢.    ᯮ 
                   ஢ 設 権  ᯮ짮
                   ஥ ஢ ᥬ.

                   筮 㬥  __emit__  ।⠢     ᥡ
                   ⮢  設 .   
                     㭪樨    ந    ᫮
                   ,   뫮  ६ .

                   ।०! ⮩ 㭪樥  ᯮ짮
                   ⮫쪮  ணࠬ,     ਥ騥   
                   設  몥  ஢  ᥬ⢠  8086.  
                    ᯮ짮   㭪    饭
                   ந  ⮢   設  㭪樨.  ᫨
                         ࠢ묨,        
                   ਢ   ࠢ  訡.  Borland  C++  
                    , 頥 ⠪ ࠧ. ᫨ 
                   設      祭 ॣ஢ 
                   ६,   Borland C++    ⮬    
                   ࠭  । ᯮ짮  , 
                       ࠡ  ஥ ᥬ஬,
                       ,   ਬ,   ᯮ   ᯮ짮
                   ॣ஢ SI  DI    ࠭  .      
                   ।⠢ ᠬ ᥡ.

                      ।  __emit__    襩    1
                   㬥;  ॠ쭮  ᫮         .
                   㬥 ⮩ 㭪樨 ᬠਢ  ⠪,  
                   㣨  㭪権:    ८ࠧ     
                   ௥.

                    ᯥ樠쭮  ࠭祭    㬥⮢
                   __emit__.            ⠭
                   ࠦ, ..  ⮡     뫮 ᯮ짮
                      樠樨   ᪨   ꥪ⮢.   
                   砥,   ࠦ  ᯮ짮 楫
                   ⠭,  ⠭  饩 窮    
                   ᪨ ꥪ⮢. 祭 뢠  窥
                   맮 㭪樨 ⠪,  ᫨  ᯮ 
                   樠樨   .    ⠪  ᯮ짮
                    ࠬ஢  ⮬᪨ ६, 
                     ⠭⭮ ᬥ饭.   㬥⮢
                    ᬥ饭 ६  BP.

                   ⢮ ,  頥      ꥪ   ,
                   ।   ⨯   㬥,     ᪫祭
                   ᫥ 砥:

                   -  楫 ⠭ (ਬ 090) 祭
                     ன               0    255
                     ᬠਢ  ᨬ.

                   -     ᯮ         ⮬᪮
                     ६      ࠬ,    ᫨  ᬥ饭
                     ६  BP     -128   127
                      뢠 ,  ᫮.

                     뢠 ᫥騬 ࠧ:

                   __emit__(0x90);

                   ᫨    ᫮,    祭
                    255,   ८ࠧ   unsigned:

                   __emit__(0xB8,(unsigned)17);

                   

                   __emit__(0xB8, 17u);

                   -   塠⮢         אַ
                   㪠   ⨯:  void near *  void far *,
                   ᮮ⢥⢥.

頥       .
祭

७ᨬ      __emit__ 㭨쭠  ᥬ⢠ 設 8086.

ਬ:

#include<dos.h>

int main()
{
   /* ⠢ ,    ࠭, १
      뢠 int 5 */
   __emit__(0xcd,0x05);  /* INT 05h */
   return 0;
}


enable

㭪            蠥 뢠.

⠪          #include<dos.h>
                   void enable(void);

, ᮤঠ騩   dos.h
⨯

ᠭ           enable ।祭           ࠢ
                   뢠ﬨ.

                   enable - ப ࠧ蠥 뢠.

頥       .
祭

७ᨬ      enable 㭨쭠  ⥬ 8086.

 ⠪     disable, getvect.

ਬ:

#include<dos.h>

void interrupt (*oldhandler)(void);

int count=0;

void interrupt handler(void)
{
   /*  㣨 뢠  ६ ࠡ⪨ ⮣ */
   disable();
   /* 㢥祭 쭮 稪 */
   count++;
   /* ࠧ襭 뢠 ᫥ ࠡ⪨ */
   enable();
   /* 맮 ன ணࠬ ࠡ⪨ */
}
int main(void)
{
   /* ࠭   */
   oldhandler = getvect(0x1c);
   /*    */
   setvect(0x1c,handler);
   /* 横,  稪  ⨣ 20 */
   while(count < 20);
   /* ⠭   */
   setvect(0x1c,oldhandler);
   return 0;
}


eof

㭪            ।, ⨣   䠩.

⠪          #include<io.h>
                   int eof(int handle);

, ᮤঠ騩   io.h
⨯

ᠭ           㭪 eof  ।,  ⨣   䠩,
                   易  ਯ஬ handle.

頥       ᫨ ⥪   殬 䠩, 㭪-
祭            eof 頥 祭 1;  ⨢ 砥
                   祭 0.     訡 頥
                   祭 -1,  쭠 ६ errno 砥
                   祭:

                     EBADF -   䠩.

७ᨬ      eof 㭨쭠  DOS.

 ⠪     clearerr, feof, ferror, perror.

ਬ:

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

int main(void)
{
   FILE *temp_file;
   int handle;
   char msg[] = "⮢ ਬ";
   char ch;
   /* ᮧ 㭨 ६ 䠩 */
   if((temp_file=tmpfile()) == NULL)
   {
      perror("⨥ 䠩:");
      exit(1);
   }
   /*  ਯ  䠩 */
   handle = fileno(temp_file);
   /*   䠩  */
   write(handle,msg,strlen(msg));
   /* ६ 㪠⥫  砫 䠩 */
   lseek(handle,0l,SEEK_SET);
   /* 뢠     䠩 */
   do
   {
      read(handle,&ch,1);
      printf("%c",ch);
   } while(!eof(handle);
                   
   /*  ६ 䠩 */
   fclose(temp_file);
   return 0;
}


execl, execle, execlp, execv, execve, execvp, execvpe

㭪            㭪樨, 㦠騥  ᪠騥 㣨 ணࠬ.

⠪          int execl(char * pathname, char * arg0, arg1, ...,
                   argn, NULL);
                   int execle(char * pathname, char * arg0, arg1,
                   ..., argn, NULL, char ** envp);
                   int execlp(char * pathname, char * arg0, arg1,
                   ..., argn, NULL);
                   int execlpe(char *  pathname, char * arg0, arg1,
                   ..., argn, NULL, char ** envp);
                   int execv(char * pathname, char * argv[]);
                   int execve(char * pathname, char * argv[],
                   char ** envp);
                   int execvp(char * pathname, char * argv[]);
                   int execvpe(char * pathname, char * argv[],
                   char ** envp);

, ᮤঠ騩   process.h
⨯

ᠭ           ⢮ 㭪権  exec...  㦠    ᪠
                   㣨    ணࠬ,         "୨"
                   .  ᫨ 맮 㭪樨  exec...  蠥
                   ᯥ譮,   "୨"      뢠  
                   "த⥫᪨"   ;   祬       
                   筮         㧪    믮
                   "୥" .

                   pathname -      䠩 뢠 "୥"
                   .   㭪樨   exec...   ந    
                   pathname,   ⠭ ⬮ ⥬
                   DOS:

                   -  ७  䠩   窨;    ⠪
                     砥  ந    筮  䠩,
                     ᫨ ⠪   ,  ७
                     .com   த. ᫨  ⠪ 䠩 
                     ,   ७ .exe    
                     믮 ᫥ ࠧ.

                   - ७       -  ந
                       筮  䠩;

                   䨪 l, v, p  e, 塞   ᥬ⢠
                   exec...   ,       㭪  㤥
                   ࠡ  묨 ᮡﬨ:

                   p - ।,  㭪 㤥 ᪠ ""
                       ணࠬ         ४,    ।塞
                       ६ । DOS PATH.  䨪 p 
                       㤥  ந ⮫쪮  ࠡ祬 ⠫.
                       ᫨ ࠬ path    ᮤন  ,  
                         ந    ⥪饩  ४ਨ,  
                       ⥬    a,  ।塞  ६
                       㦥 PATH.

                   l - 뢠,   㪠⥫ (arg0, arg1,
                       ..., argn) ।,  ⤥ 㬥.
                       筮 䨪 l 㯮ॡ,  ᫮ -
                        㬥⮢ ࠭  ⭮.

                   v - 뢠,      㪠⥫  (arg[0],
                       arg[1],...arg[n])    ।,      ᨢ
                       㪠⥫.  筮,  䨪  v  ᯮ,
                        ।e ६ ᫮ 㬥⮢.

                   e - 뢠,  "୥"   
                       ।  㬥   envp,      
                       롨   ।   "୥"   .  
                       䨪 e "୨"  㭠᫥  ।
                       "த⥫᪮" .

                    㭪 ᥬ⢠ exec...    
                     䨪ᮢ,  । 㬥 ( l,
                     v).  䨪  ।    㯠
                   (PATH)  㭠᫥ 樮 । (p    e)
                    易⥫묨.

                   ਬ:

                   - execl  -  ।⠢  ᮡ  㭪  ᥬ⢠
                     exec...,   । ࠧ  㬥,
                      "୨"  ⮫쪮  ࠡ祬 ⠫
                       ।  "த⥫"   ।   "୥"
                     .

                   - execvpe   ।⠢  ᮡ  㭪  ᥬ⢠
                     exec...,    ।   ᨢ   㪠⥫
                     㬥⮢, ᮥ  㯠 PATH 
                     ᪠ "୥"   ਬ  㬥
                     envp  롮 । "୥" .

                   㭪 ᥬ⢠    exec...       ।
                   "୥"       㬥  (arg0
                      argv[0]).    㬥,    ᮣ襭,
                   ।⠢ ᮡ   pathname.  (ᯮ짮
                   㣨  祭    㫥  㬥  㤥
                   訡).

                    ⥬ DOS ᨩ 3.X "୨"   
                    㬥 pathname;    ࠭ 
                   "୨"     ᯮ짮  祭
                   㫥 㬥 (arg0  argn[0]).

                    ᯮ짮 䨪 l, 0 筮 㪠뢠
                    pathname,   arg1, ..., argn 㪠뢠  ப
                   ᨬ,        ନ       ᯨ᮪
                   㬥⮢.  騩 NULL,  ᫥騩   argn,
                   砥  ᯨ᪠.
                   
                    ᯮ짮  䨪  e  ᯨ᮪  祭
                   । ।   㬥  envp.  
                   㬥  ᨢ  ⮢ ⨯ char*.
                     㪠뢠    ᨬ  ப  
                   㫥 砭 :

                          envvar = value , 

                   envvar -    ६ ।,   value- 祭
                   ᨬ쭮  ப,    ᢠ  
                   ६  envvar.  ᫥  ⮬  ᨢ
                   envp[]    NULL.  祭
                   envp[0]  NULL, "୨"  ᫥
                   祭 । "த⥫᪮" .

                      arg0+   arg1+...+argn   (   arg[0]+
                   arg[1]+...+arg[n]),    ஡,  ࠧ騥
                   㬥,     128 ⮢.  㫥
                   砭  .
                   
                    맮  㭪樨  exec...     䠩
                    묨   "୥" .

頥        ᯥ譮 襭 㭪樨 exec...  -
祭             祭.   訡
                   㭪樨 exec...      祭    -1,    
                   쭠   ६   errno  砥    
                   ᫥ 祭:

                   E2BIG  - 誮  ᯨ᮪ 㬥⮢.
                   EACCES - ⪠ 㯠.
                   EMFILE - 誮   䠩.
                   ENOENT -  㯠 (PATH)   䠩 
                            .
                   ENOEXEC - 訡 ଠ EXEC.
                   ENOMEM  -  墠⠥ .

७ᨬ      exec... 㭨쭠  DOS.

 ⠪:    abort, atexit,_exit, exit, _fpreset, searchpath,
                   spawn..., system.

ਬ:

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

main(int argc, char * argv[])
{
   int i;
   printf("饭 ୨  ...\n");
   printf("%s\n",getenv("PATH"));
   for (i=0; i<argc; i++)
      printf("argv[%d]: %s\n", 1, argv[i]);
}

#include<stdio.h>
#include<errno.h>
#include<dos.h>

int main(int argc,char *argv[])
{
    int loop;
    printf("%s ࠡ⠥...\n\n",argv[0]);
    if(argc == 1)  /*    㬥 */
    {
       printf("%s ᪠ ᠬ ᥡ ...\n",argv[0]);
       execl(argv[0],argv[0],"ONE","TWO","THREE",NULL);
       perror("EXEC:");
       exit(1);
    }
    printf("%s 맢  㬥⠬:\n",argv[0]);
    for(loop = 1;loop<=argc;loop++)
       puts(argv[loop]);
    return 0;
}


#include<process.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<dos.h>

int main(int argc,char *argv[])
{
    int loop;
    char *new_env[] = {"TELYING",NULL};

    printf("%s ࠡ⠥...\n\n",argv[0]);
    if(argc == 1)  /*    㬥 */
    {
       printf("%s ᪠ ᠬ ᥡ ...\n",argv[0]);
       execle(argv[0],argv[0],"ONE","TWO","THREE",NULL,new_env);
       perror("EXEC:");
       exit(1);
    }
    printf("%s 맢  㬥⠬:\n",argv[0]);
    for(loop = 1;loop<=argc;loop++)
       puts(argv[loop]);

    /*   ࠬ । */
    printf("env[0] = %s\n",env[0]);
    return 0;
}
                   
                   
#include<process.h>
#include<stdio.h>
#include<errno.h>
#include<dos.h>

int main(int argc,char *argv[])
{
    int loop;
    printf("%s ࠡ⠥...\n\n",argv[0]);
    if(argc == 1)  /*    㬥 */
    {
       printf("%s ᪠ ᠬ ᥡ ...\n",argv[0]);
       execlp(argv[0],argv[0],"ONE","TWO","THREE",NULL);
       perror("EXEC:");
       exit(1);
    }
    printf("%s 맢  㬥⠬:\n",argv[0]);
    for(loop = 1;loop<=argc;loop++)
       puts(argv[loop]);
    return 0;
}

#include<process.h>
#include<stdio.h>
#include<errno.h>
#include<stdlib.h>
#include<string.h>
#include<dos.h>

void main(int argc,char *argv[],char **envp)
{
    printf(" CHILD  arg1, arg2 ...\n");
    execlpe("CHILD.EXE","CHILD.EXE","arg1","arg2",NULL,envp);
    perror("訡 EXEC");
    exit(1);
}

#include<process.h>
#include<stdio.h>
#include<errno.h>
#include<stdlib.h>
#include<string.h>
#include<dos.h>

void main(int argc,char **argv)
{
    printf(" CHILD  arg1, arg2 ...\n");
    execv("CHILD.EXE",argv);
    perror("訡 EXEC");
    exit(1);
}


#include<process.h>
#include<stdio.h>
#include<errno.h>
#include<stdlib.h>
#include<string.h>
#include<dos.h>

void main(int argc,char **argv,char **envp)
{
    printf(" CHILD  arg1, arg2 ...\n");
    execve("CHILD.EXE",argv,envp);
    perror("訡 EXEC");
    exit(1);
}

#include<process.h>
#include<stdio.h>
#include<errno.h>
#include<stdlib.h>
#include<string.h>
#include<dos.h>

void main(int argc,char **argv)
{
    printf(" CHILD  arg1, arg2 ...\n");
    execvp("CHILD.EXE",argv);
    perror("訡 EXEC");
    exit(1);
}

#include<process.h>
#include<stdio.h>
#include<errno.h>
#include<stdlib.h>
#include<string.h>
#include<dos.h>

int main(int argc,char **argv,char **envp)
{
    printf(" CHILD  arg1, arg2 ...\n");
    execvpe("CHILD.EXE",argv,envp);
    perror("訡 EXEC");
    exit(1);
}


_exit

㭪            ४頥 믮 ணࠬ.

⠪          #include<stdlib.h>
                   void _exit(int status);

, ᮤঠ騩   process.h, stdlib.h
⨯

ᠭ           㭪 _exit  稢       
                   -  䠩,  ࠭ - 뢮,
                   맮 - "㭪権 室".

                        砥,        뢠   
                   ᯥ稢     㬥     status,     
                   ।⠢   ᮡ     室    
                   .    筮    祭,    ࠢ    ,
                   ᯮ   祭 ଠ쭮 室 
                   , 㫥 祭 砥 -
                   訡.

頥       .
祭

७ᨬ      _exit 㯭  ⥬ UNIX.

 ⠪       abort, atexit, exec..., exit, spawn...

ਬ:

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

void dose(void);

int main(void)
{
   atexit(dose);
   _exit(0);
   return 0;
}
void dose()
{
   printf("ਢ\n");
}


exit

㭪            ४頥 믮 ணࠬ.

⠪          #include<stdlib.h>
                   void exit(int status);

, ᮤঠ騩   process.h, stdlib.h
⨯

ᠭ           㭪 exit ४頥 뢠  .  ।
                   室            䠩  뢠,
                   뢠    뢮  (騩  뢮)   
                   뢠   ॣ஢   "㭪樨  室"
                   (  㭪樨 atexit).

                        砥,        뢠   
                   ᯥ稢     㬥     status,     
                   ।⠢   ᮡ     室    
                   .   筮,    祭,    ࠢ    ,
                   ᯮ   祭 ଠ쭮 室 
                   , 㫥 祭 砥 -
                   訡.  ⠭   ᫥:

                   EXIT_SUCCESS -  ଠ쭮 襭.
                   
                   EXIT_FAILURE -  ଠ쭮 襭. 頥
                                   樮 ⥬,  ணࠬ
                                   訫  訡.

頥       .
祭

७ᨬ      㭪 exit ᮢ⨬  ⥬ UNIX  ।-
                     ⠭ ANSI C.

 ⠪     㭪樨 abort, atexit, exec..., _exit, spawn...,
                   keep  signal.

ਬ:

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

int main(void)
{
   int status;
   printf("  1  2\n");
   status = getch();
   exit(status-'0');
   return 0;  /*  窠  ⨣ */
}


exp

㭪            㭪 ᯮ; 頥 祭   ⥯
                   x.

⠪          ⢥        ᭠ 
                   #include<math.h>          #include<complex.h>
                   double exp(double x);     complex exp(complex x);

, ᮤঠ騩   ⢥        ᭠ 
⨯           math.h                    complex.h

ᠭ           㭪 exp  㭪 ᯮ e^x;

                   ᯮ ᭮ ᫠ ।  ᫥騬
                   ࠧ:

                      exp(x+yi) = exp(x)(cos(y)+i sin(y))

頥       exp  頥 e^x.
祭

                    㬥  㭪樨  exp  뤠   १,
                   뢠騩  ९   塞.  
                   ୮ 祭 뢠 ९,  㭪 exp
                   頥 祭 HUGE_VAL.  १୮ 讬
                   १     쭮     ६      errno
                   ᢠ 祭:

                   ERANGE - १ ॢ蠥 ⨬ ।.

                      १  頥  0.0  errno 
                   .

                   ࠡ 訡  exp      
                   matherr.

७ᨬ      㭪樨 ন  ⥬ UNIX  ⠭-
                   ⮬ ANSI C.

 ⠪     㭪樨 frexp, ldexp, log, log10, matherr,pow,
                   pow10, sqrt.

ਬ:

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

int main(void)
{
   double result;
   double x = 4.0;
   result = exp(x);
   printf("'e'  ⥯ %1f (e^%1f) = %1f\n",x,x,result);
   return 0;
}

