C语言之简易了解程序环境

大纲：

  • 程序的翻译环境

    • 预编译
    • 编译
    • 汇编
    • 链接
  • 程序的运行环境

　　在ANSI C的任何一种实现中，存在两个不同的环境。

　　　　第1种是翻译环境，在这个环境中源代码被转换为可执行的机器指令。

　　　　第2种是执行环境，它用于实际执行代码。

一.程序的翻译环境

　　我们上手的第一个C语言程序大致都是 “Hello World！”吧！

　　可是，不知道大家想过没有？一个代码文件，是怎么转换成了我们可运行的exe文件呢，而且我们都知道计算机是只能看得懂二进制文件，所以再进一层说：

　　一个 .c 文件是怎么转换为 .exe 文件的呢？这就是通过翻译环境来实现的。而翻译环境又包括编译和链接，编译又分为预编译，编译和汇编。

　　接下来，我们就来看看它们到底干了什么：

1.预编译

　　预编译过程主要处理以 # 开头的语句，如#include，#define 等

　　而预编译都干了一些什么呢，主要如下：

　　　　1.头文件的包含

　　　　2.注释的删除

　　　　3.#define定义的符号的替换

　　　　4.处理一些条件预处理指令，如 #if 、 #ifdef  等等（这个我们会在后面提到）

　　　　5.保留所有的 #pragma 命令

　　　　6.一些文本操作

　　假设我们这里有一份代码：

#include<stdio.h>

#define NUM 10

int main()

{

        int i = 0;

        for(i=0;i<NUM;i++)

        {

                printf("%d \n",i);

        }

        return 0;

}

　　我们来看看它预编译之后产生什么：

# 1 "test.c"

# 1 "<built-in>"

# 1 "<命令行>"

# 31 "<命令行>"

# 1 "/usr/include/stdc-predef.h" 1 3 4

# 32 "<命令行>" 2

# 1 "test.c"

# 1 "/usr/include/stdio.h" 1 3 4

# 27 "/usr/include/stdio.h" 3 4

# 1 "/usr/include/features.h" 1 3 4

# 375 "/usr/include/features.h" 3 4

# 1 "/usr/include/sys/cdefs.h" 1 3 4

# 392 "/usr/include/sys/cdefs.h" 3 4

# 1 "/usr/include/bits/wordsize.h" 1 3 4

# 393 "/usr/include/sys/cdefs.h" 2 3 4

# 376 "/usr/include/features.h" 2 3 4

# 399 "/usr/include/features.h" 3 4

# 1 "/usr/include/gnu/stubs.h" 1 3 4

# 10 "/usr/include/gnu/stubs.h" 3 4

# 1 "/usr/include/gnu/stubs-64.h" 1 3 4

# 11 "/usr/include/gnu/stubs.h" 2 3 4

# 400 "/usr/include/features.h" 2 3 4

# 28 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/local/lib/gcc/x86_64-pc-linux-gnu/8.3.0/include/stddef.h" 1 3 4

# 216 "/usr/local/lib/gcc/x86_64-pc-linux-gnu/8.3.0/include/stddef.h" 3 4

# 216 "/usr/local/lib/gcc/x86_64-pc-linux-gnu/8.3.0/include/stddef.h" 3 4

typedef long unsigned int size_t;

# 34 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/bits/types.h" 1 3 4

# 27 "/usr/include/bits/types.h" 3 4

# 1 "/usr/include/bits/wordsize.h" 1 3 4

# 28 "/usr/include/bits/types.h" 2 3 4

typedef unsigned char __u_char;

typedef unsigned short int __u_short;

typedef unsigned int __u_int;

typedef unsigned long int __u_long;

typedef signed char __int8_t;

typedef unsigned char __uint8_t;

typedef signed short int __int16_t;

typedef unsigned short int __uint16_t;

typedef signed int __int32_t;

typedef unsigned int __uint32_t;

typedef signed long int __int64_t;

typedef unsigned long int __uint64_t;

typedef long int __quad_t;

typedef unsigned long int __u_quad_t;

# 130 "/usr/include/bits/types.h" 3 4

# 1 "/usr/include/bits/typesizes.h" 1 3 4

# 131 "/usr/include/bits/types.h" 2 3 4

typedef unsigned long int __dev_t;

typedef unsigned int __uid_t;

typedef unsigned int __gid_t;

typedef unsigned long int __ino_t;

typedef unsigned long int __ino64_t;

typedef unsigned int __mode_t;

typedef unsigned long int __nlink_t;

typedef long int __off_t;

typedef long int __off64_t;

typedef int __pid_t;

typedef struct { int __val[2]; } __fsid_t;

typedef long int __clock_t;

typedef unsigned long int __rlim_t;

typedef unsigned long int __rlim64_t;

typedef unsigned int __id_t;

typedef long int __time_t;

typedef unsigned int __useconds_t;

typedef long int __suseconds_t;

typedef int __daddr_t;

typedef int __key_t;

typedef int __clockid_t;

typedef void * __timer_t;

typedef long int __blksize_t;

typedef long int __blkcnt_t;

typedef long int __blkcnt64_t;

typedef unsigned long int __fsblkcnt_t;

typedef unsigned long int __fsblkcnt64_t;

typedef unsigned long int __fsfilcnt_t;

typedef unsigned long int __fsfilcnt64_t;

typedef long int __fsword_t;

typedef long int __ssize_t;

typedef long int __syscall_slong_t;

typedef unsigned long int __syscall_ulong_t;

typedef __off64_t __loff_t;

typedef __quad_t *__qaddr_t;

typedef char *__caddr_t;

typedef long int __intptr_t;

typedef unsigned int __socklen_t;

# 36 "/usr/include/stdio.h" 2 3 4

# 44 "/usr/include/stdio.h" 3 4

struct _IO_FILE;

typedef struct _IO_FILE FILE;

# 64 "/usr/include/stdio.h" 3 4

typedef struct _IO_FILE __FILE;

# 74 "/usr/include/stdio.h" 3 4

# 1 "/usr/include/libio.h" 1 3 4

# 32 "/usr/include/libio.h" 3 4

# 1 "/usr/include/_G_config.h" 1 3 4

# 15 "/usr/include/_G_config.h" 3 4

# 1 "/usr/local/lib/gcc/x86_64-pc-linux-gnu/8.3.0/include/stddef.h" 1 3 4

# 16 "/usr/include/_G_config.h" 2 3 4

# 1 "/usr/include/wchar.h" 1 3 4

# 82 "/usr/include/wchar.h" 3 4

typedef struct

{

  int __count;

  union

  {

    unsigned int __wch;

    char __wchb[4];

  } __value;

} __mbstate_t;

# 21 "/usr/include/_G_config.h" 2 3 4

typedef struct

{

  __off_t __pos;

  __mbstate_t __state;

} _G_fpos_t;

typedef struct

{

  __off64_t __pos;

  __mbstate_t __state;

} _G_fpos64_t;

# 33 "/usr/include/libio.h" 2 3 4

# 50 "/usr/include/libio.h" 3 4

# 1 "/usr/local/lib/gcc/x86_64-pc-linux-gnu/8.3.0/include/stdarg.h" 1 3 4

# 40 "/usr/local/lib/gcc/x86_64-pc-linux-gnu/8.3.0/include/stdarg.h" 3 4

typedef __builtin_va_list __gnuc_va_list;

# 51 "/usr/include/libio.h" 2 3 4

# 145 "/usr/include/libio.h" 3 4

struct _IO_jump_t; struct _IO_FILE;

# 155 "/usr/include/libio.h" 3 4

typedef void _IO_lock_t;

struct _IO_marker {

  struct _IO_marker *_next;

  struct _IO_FILE *_sbuf;

  int _pos;

# 178 "/usr/include/libio.h" 3 4

};

enum __codecvt_result

{

  __codecvt_ok,

  __codecvt_partial,

  __codecvt_error,

  __codecvt_noconv

};

# 246 "/usr/include/libio.h" 3 4

struct _IO_FILE {

  int _flags;

  char* _IO_read_ptr;

  char* _IO_read_end;

  char* _IO_read_base;

  char* _IO_write_base;

  char* _IO_write_ptr;

  char* _IO_write_end;

  char* _IO_buf_base;

  char* _IO_buf_end;

  char *_IO_save_base;

  char *_IO_backup_base;

  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;

  int _flags2;

  __off_t _old_offset;

  unsigned short _cur_column;

  signed char _vtable_offset;

  char _shortbuf[1];

  _IO_lock_t *_lock;

# 294 "/usr/include/libio.h" 3 4

  __off64_t _offset;

# 303 "/usr/include/libio.h" 3 4

  void *__pad1;

  void *__pad2;

  void *__pad3;

  void *__pad4;

  size_t __pad5;

  int _mode;

  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];

};

typedef struct _IO_FILE _IO_FILE;

struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;

extern struct _IO_FILE_plus _IO_2_1_stdout_;

extern struct _IO_FILE_plus _IO_2_1_stderr_;

# 339 "/usr/include/libio.h" 3 4

typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);

typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,

     size_t __n);

typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);

typedef int __io_close_fn (void *__cookie);

# 391 "/usr/include/libio.h" 3 4

extern int __underflow (_IO_FILE *);

extern int __uflow (_IO_FILE *);

extern int __overflow (_IO_FILE *, int);

# 435 "/usr/include/libio.h" 3 4

extern int _IO_getc (_IO_FILE *__fp);

extern int _IO_putc (int __c, _IO_FILE *__fp);

extern int _IO_feof (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));

extern int _IO_ferror (_IO_FILE *__fp) __attribute__ ((__nothrow__ , __leaf__));

extern int _IO_peekc_locked (_IO_FILE *__fp);

extern void _IO_flockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));

extern void _IO_funlockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));

extern int _IO_ftrylockfile (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));

# 465 "/usr/include/libio.h" 3 4

extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,

   __gnuc_va_list, int *__restrict);

extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,

    __gnuc_va_list);

extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);

extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);

extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);

extern void _IO_free_backup_area (_IO_FILE *) __attribute__ ((__nothrow__ , __leaf__));

# 75 "/usr/include/stdio.h" 2 3 4

typedef __gnuc_va_list va_list;

# 90 "/usr/include/stdio.h" 3 4

typedef __off_t off_t;

# 102 "/usr/include/stdio.h" 3 4

typedef __ssize_t ssize_t;

typedef _G_fpos_t fpos_t;

# 164 "/usr/include/stdio.h" 3 4

# 1 "/usr/include/bits/stdio_lim.h" 1 3 4

# 165 "/usr/include/stdio.h" 2 3 4

extern struct _IO_FILE *stdin;

extern struct _IO_FILE *stdout;

extern struct _IO_FILE *stderr;

extern int remove (const char *__filename) __attribute__ ((__nothrow__ , __leaf__));

extern int rename (const char *__old, const char *__new) __attribute__ ((__nothrow__ , __leaf__));

extern int renameat (int __oldfd, const char *__old, int __newfd,

       const char *__new) __attribute__ ((__nothrow__ , __leaf__));

extern FILE *tmpfile (void) ;

# 209 "/usr/include/stdio.h" 3 4

extern char *tmpnam (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;

extern char *tmpnam_r (char *__s) __attribute__ ((__nothrow__ , __leaf__)) ;

# 227 "/usr/include/stdio.h" 3 4

extern char *tempnam (const char *__dir, const char *__pfx)

     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__malloc__)) ;

extern int fclose (FILE *__stream);

extern int fflush (FILE *__stream);

# 252 "/usr/include/stdio.h" 3 4

extern int fflush_unlocked (FILE *__stream);

# 266 "/usr/include/stdio.h" 3 4

extern FILE *fopen (const char *__restrict __filename,

      const char *__restrict __modes) ;

extern FILE *freopen (const char *__restrict __filename,

        const char *__restrict __modes,

        FILE *__restrict __stream) ;

# 295 "/usr/include/stdio.h" 3 4

# 306 "/usr/include/stdio.h" 3 4

extern FILE *fdopen (int __fd, const char *__modes) __attribute__ ((__nothrow__ , __leaf__)) ;

# 319 "/usr/include/stdio.h" 3 4

extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)

  __attribute__ ((__nothrow__ , __leaf__)) ;

extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) __attribute__ ((__nothrow__ , __leaf__)) ;

extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) __attribute__ ((__nothrow__ , __leaf__));

extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,

      int __modes, size_t __n) __attribute__ ((__nothrow__ , __leaf__));

extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,

         size_t __size) __attribute__ ((__nothrow__ , __leaf__));

extern void setlinebuf (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));

extern int fprintf (FILE *__restrict __stream,

      const char *__restrict __format, ...);

extern int printf (const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,

      const char *__restrict __format, ...) __attribute__ ((__nothrow__));

extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,

       __gnuc_va_list __arg);

extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, const char *__restrict __format,

       __gnuc_va_list __arg) __attribute__ ((__nothrow__));

extern int snprintf (char *__restrict __s, size_t __maxlen,

       const char *__restrict __format, ...)

     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,

        const char *__restrict __format, __gnuc_va_list __arg)

     __attribute__ ((__nothrow__)) __attribute__ ((__format__ (__printf__, 3, 0)));

# 412 "/usr/include/stdio.h" 3 4

extern int vdprintf (int __fd, const char *__restrict __fmt,

       __gnuc_va_list __arg)

     __attribute__ ((__format__ (__printf__, 2, 0)));

extern int dprintf (int __fd, const char *__restrict __fmt, ...)

     __attribute__ ((__format__ (__printf__, 2, 3)));

extern int fscanf (FILE *__restrict __stream,

     const char *__restrict __format, ...) ;

extern int scanf (const char *__restrict __format, ...) ;

extern int sscanf (const char *__restrict __s,

     const char *__restrict __format, ...) __attribute__ ((__nothrow__ , __leaf__));

# 443 "/usr/include/stdio.h" 3 4

extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")

                               ;

extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")

                              ;

extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) __asm__ ("" "__isoc99_sscanf") __attribute__ ((__nothrow__ , __leaf__))

                      ;

# 463 "/usr/include/stdio.h" 3 4

extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,

      __gnuc_va_list __arg)

     __attribute__ ((__format__ (__scanf__, 2, 0))) ;

extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)

     __attribute__ ((__format__ (__scanf__, 1, 0))) ;

extern int vsscanf (const char *__restrict __s,

      const char *__restrict __format, __gnuc_va_list __arg)

     __attribute__ ((__nothrow__ , __leaf__)) __attribute__ ((__format__ (__scanf__, 2, 0)));

# 494 "/usr/include/stdio.h" 3 4

extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")

     __attribute__ ((__format__ (__scanf__, 2, 0))) ;

extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")

     __attribute__ ((__format__ (__scanf__, 1, 0))) ;

extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vsscanf") __attribute__ ((__nothrow__ , __leaf__))

     __attribute__ ((__format__ (__scanf__, 2, 0)));

# 522 "/usr/include/stdio.h" 3 4

extern int fgetc (FILE *__stream);

extern int getc (FILE *__stream);

extern int getchar (void);

# 550 "/usr/include/stdio.h" 3 4

extern int getc_unlocked (FILE *__stream);

extern int getchar_unlocked (void);

# 561 "/usr/include/stdio.h" 3 4

extern int fgetc_unlocked (FILE *__stream);

extern int fputc (int __c, FILE *__stream);

extern int putc (int __c, FILE *__stream);

extern int putchar (int __c);

# 594 "/usr/include/stdio.h" 3 4

extern int fputc_unlocked (int __c, FILE *__stream);

extern int putc_unlocked (int __c, FILE *__stream);

extern int putchar_unlocked (int __c);

extern int getw (FILE *__stream);

extern int putw (int __w, FILE *__stream);

extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)

     ;

# 640 "/usr/include/stdio.h" 3 4

# 665 "/usr/include/stdio.h" 3 4

extern __ssize_t __getdelim (char **__restrict __lineptr,

          size_t *__restrict __n, int __delimiter,

          FILE *__restrict __stream) ;

extern __ssize_t getdelim (char **__restrict __lineptr,

        size_t *__restrict __n, int __delimiter,

        FILE *__restrict __stream) ;

extern __ssize_t getline (char **__restrict __lineptr,

       size_t *__restrict __n,

       FILE *__restrict __stream) ;

extern int fputs (const char *__restrict __s, FILE *__restrict __stream);

extern int puts (const char *__s);

extern int ungetc (int __c, FILE *__stream);

extern size_t fread (void *__restrict __ptr, size_t __size,

       size_t __n, FILE *__restrict __stream) ;

extern size_t fwrite (const void *__restrict __ptr, size_t __size,

        size_t __n, FILE *__restrict __s);

# 737 "/usr/include/stdio.h" 3 4

extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,

         size_t __n, FILE *__restrict __stream) ;

extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,

          size_t __n, FILE *__restrict __stream);

extern int fseek (FILE *__stream, long int __off, int __whence);

extern long int ftell (FILE *__stream) ;

extern void rewind (FILE *__stream);

# 773 "/usr/include/stdio.h" 3 4

extern int fseeko (FILE *__stream, __off_t __off, int __whence);

extern __off_t ftello (FILE *__stream) ;

# 792 "/usr/include/stdio.h" 3 4

extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);

extern int fsetpos (FILE *__stream, const fpos_t *__pos);

# 815 "/usr/include/stdio.h" 3 4

# 824 "/usr/include/stdio.h" 3 4

extern void clearerr (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));

extern int feof (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;

extern int ferror (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;

extern void clearerr_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));

extern int feof_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;

extern int ferror_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;

extern void perror (const char *__s);

# 1 "/usr/include/bits/sys_errlist.h" 1 3 4

# 26 "/usr/include/bits/sys_errlist.h" 3 4

extern int sys_nerr;

extern const char *const sys_errlist[];

# 854 "/usr/include/stdio.h" 2 3 4

extern int fileno (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;

extern int fileno_unlocked (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;

# 873 "/usr/include/stdio.h" 3 4

extern FILE *popen (const char *__command, const char *__modes) ;

extern int pclose (FILE *__stream);

extern char *ctermid (char *__s) __attribute__ ((__nothrow__ , __leaf__));

# 913 "/usr/include/stdio.h" 3 4

extern void flockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));

extern int ftrylockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__)) ;

extern void funlockfile (FILE *__stream) __attribute__ ((__nothrow__ , __leaf__));

# 943 "/usr/include/stdio.h" 3 4

# 2 "test.c" 2

# 4 "test.c"

int result = 0;

int ADD(int x, int y)

{

 return x + y;

}

int main()

{

 int a = 10;

 result = ADD(a, 10);

 printf("%d+%d=%d\n", a, 10, result);

 return 0;

}

test.i

　　我们看到test.i文件居然包含了快900行代码，而且我们会看到现在的生成的文件效果跟我们上面所提到的相符，如删除注释，替换#define替换的符号等

注：

　　可以用 set nu 来查看行数

　　怎么生成 .i文件（即预编译后的文件）呢？

　　　　在gcc编译器下我们可以使用如下指令：

　　　　　　1. gcc -E test.c > test.i 

　　　　　　2. gcc -E test.c -o test.i 

2.编译

　　在预编译之后就是编译了，我们可以用 gcc -S test.c > test.s 来生成编译后的文件，我们可以用vim test.s来查看其内容，内容如下：

    .file    "test.c"

    .text

    .globl    result

    .bss

    .align 4

    .type    result, @object

    .size    result, 4

result:

    .zero    4

    .text

    .globl    ADD

    .type    ADD, @function

ADD:

.LFB0:

    .cfi_startproc

    pushq    %rbp

    .cfi_def_cfa_offset 16

    .cfi_offset 6, -16

    movq    %rsp, %rbp

    .cfi_def_cfa_register 6

    movl    %edi, -4(%rbp)

    movl    %esi, -8(%rbp)

    movl    -4(%rbp), %edx

    movl    -8(%rbp), %eax

    addl    %edx, %eax

    popq    %rbp

    .cfi_def_cfa 7, 8

    ret

    .cfi_endproc

.LFE0:

    .size    ADD, .-ADD

    .section    .rodata

.LC0:

    .string    "%d+%d=%d\n"

    .text

    .globl    main

    .type    main, @function

main:

.LFB1:

    .cfi_startproc

    pushq    %rbp

    .cfi_def_cfa_offset 16

    .cfi_offset 6, -16

    movq    %rsp, %rbp

    .cfi_def_cfa_register 6

    subq    $16, %rsp

    movl    $10, -4(%rbp)

    movl    -4(%rbp), %eax

    movl    $10, %esi

    movl    %eax, %edi

    call    ADD

    movl    %eax, result(%rip)

    movl    result(%rip), %edx

    movl    -4(%rbp), %eax

    movl    %edx, %ecx

    movl    $10, %edx

    movl    %eax, %esi

    movl    $.LC0, %edi

    movl    $0, %eax

    call    printf

    movl    $0, %eax

    leave

    .cfi_def_cfa 7, 8

    ret

    .cfi_endproc

.LFE1:

    .size    main, .-main

    .ident    "GCC: (GNU) 8.3.0"

    .section    .note.GNU-stack,"",@progbits

test.s

　　而程序在编译阶段是将我们的c代码转为了汇编代码，包含如下内容：

　　　　1.词法分析

　　首先源代码程序被输入到扫描器（Scanner）,扫描器的任务很简单,它只是简单地进 行词法分析,运用一种类似于有限状态机（Finite State Machine）的算法可以很轻松地将源 代码的字符序列分割成一系列的记号（Token）。

　　词法分析产生的记号一般可以分为如下几类：关键字、标识符、字面量（包含数字、字 符串等）和特殊符号（如加号、等号〉。在识别记号的同时，扫描器也完成了其他工作。比如将标识符存放到符号表，将数字、字符串常景存放到文字表等，以备后面的步骤使用。 有一个叫做lex的程序可以实现同法扫描，它会按照用户之前描述好的词法规则将输入的字符串分割成一个个记号。因为这样一个程序的存在，编译器的开发者就无须为每个编译器开发一个独立的词法扫描器，而是根据需要改变词法规则就可以了。

　　　　　　另外对于一些有预处理的语言，比如C语言，它的宏替换和文件包含等工作一般不归入编译器的范围而交给一个独立的预处理器。

　　　　2.语法分析

　　接下来语法分析器(Grammar Parser)将对由扫描器产生的记号进行语法分析，从而 产生语法树(SyntaxTree)。整个分析过程采用了上下文无关语法(Context-free Grammar) 的分析手段，如果你对上下文无关语法及下推自动机很熟悉，那么应该很好理解。否则，可以参考一些计算理论的资料，一般都会有很详细的介绍。此处不再赘述。简单地讲，由语法分析器生成的语法树就是以表达式(Expression)为节点的树。我们知道，C语言的一个语句是一个表达式，而复杂的语句是很多表达式的组合。

　　　　上面例子中的语句就是一个由赋值表达式、加法表达式、乘法表达式、数组表达式、括号表达式组成的复杂语句。它在经过语法分析器以后形成如图所示的语法树。

　　此例文件：

　　从图屮我们可以看到，整个语句被看作是一个赋值表达式；赋值表达式的左边是一个数组表达式，它的右边是一个乘法表达式；数组表达式又由两个符号表达式组成，等等。 符号和数字是最小的表达式，它们不是由其他的表达式来组成的，所以它们通常作为整个语法树的叶节点。在语法分析的同时，很多运算符号的优先级和含义也被确定下来了。比如乘法表达式的优先级比加法高，而圆括号表达式的优先级比乘法髙，等等。另外有些符号具有多重含义，比如星号*在C语言中可以表示乘法表达式，也可以表示对指针取内容的表达式， 所以语法分析阶段必须对这些内容进行区分。如果出现了表达式不合法，比如各种括号不匹配、表达式中缺少操作符等，编译器就会报告语法分析阶段的错误。 正如前面词法分析有lex 一样，语法分析也有一个现成的工具叫做yacc (Yet Another CompilerCompiler)。它也像lex 样，可以根据用户给定的语法规则对输入的记号序列进行 解析，从而构建出一棵语法树。对于不同的编程语言，编译器的开发者只须改变语法规则， 而无须为每个编译器编写一个语法分析器，所以它又被称为“编译器编译器(Compiler Compiler)**。

　　　　3.语义分析

　　接下米进行可以看到，每个表达式（包括符号和数字）都被标识了类型。我们的例子中几乎所有的 表达式都是整型的，所以无须做转换，整个分析过程很顺利。语义分析器还对符号表里的符 号类型也做了更新。的是语义分析，由语义分析器(Semantic Analyzer)来完成。语法分析仅 仪是完成了对表达式的语法层面的分析，但是它并不了解这个语句是否真正有意义。比如C 语言里囱两个指针做乘法运算是没有意义的，但是这个语句在语法上是合法的；比如同样一 个指针和一个浮点数做乘法运算是否合法等。编译器所能分析的语义是静态语义(Static Semantic),所谓静态语义是指在编译期可以确定的语义，与之对应的动态语义(DynamicSemantic）就是只有在运行期才能确定的语义。 静态语义通常包括声明和类型的匹配，类型的转换。比如当一个浮点型的表达式赋值给 一个整型的表达式时，其屮隐含了一个浮点型到整型转换的过程，语义分析过程中需要完成 这个步骤。比如将一个浮点型赋值给一个指针的时候，语义分析程序会发现这个类型不匹配， 编译器将会报错。动态语义一般指在运行期出现的语义相关的问题，比如将0作为除数是一个运行期语义错误。 经过语义分析阶段以后，整个语法树的表达式都被标识了类型，如果有些类型需要做隐式转换，语义分析程序会在语法树屮插入相应的转换节点。上面描述的语法树在经过语义分析阶段以后成为如图2-4所示的形式。

　　　　　　可以看到，每个表达式（包括符号和数字）都被标识了类型。我们的例子中几乎所有的表达式都是整型的，所以无须做转换，整个分析过程很顺利。语义分析器还对符号表里的符号类型也做了更新。

　　　　4.符号汇总

　　　　　　对于符号汇总，我们可以先生成 .o文件来查看一下我们一开始的例子所拥有的符号，命令: gcc -c test.c ,然后再用 readelf -s test.o 来查看所拥有的符号。

　　我们再对比源代码，发现符号都是全局变量，以及一个我们使用的库函数，而这些符号都是所参与我们编译文件的符号的一个汇总，如：我现在有两个.c文件，一个是含有add符号，另外一个含有main符号，那么，汇总后就是add，main。

3.汇编

　　这个阶段的主要工作是将汇编代码转换为二进制指令（包括形成符号表 --- 将汇总的符号与地址联系起来），如果我们不指定阅读器打开，就会显示一堆乱码。命令就是刚刚用来查看符号的第一步： gcc -c test.c 然后，我们发现我们的路径底下多了一个test.o文件。（要是你使用的是coldblocks软件来写你的c程序，运行完再相应文件夹都会出现 .o 文件）

　　注：

　　　　形成符号表：

　　经过这些扫描、语法分析、语义分析、源代码优化、代码生成和目标代码优化，编译器 忙活了这么多个步骤以后，源代码终于被编译成了目标代码。但是这个目标代码中有一个问 题是：一些函数符号的地址还没有确定。如果我们要把目标代码使用汇编器编译成真正能够在机器上执行的指令，那么它们的地址应该从哪儿得到呢？如果它们的定义在跟上面的源代码同一个编译单元里面，那么编译器可以为它们分配空间， 确定它们的地址：那如果是定义在其他的程序模块呢？

　　这个看似简单的问题引出了我们一个很大的话题：冃标代码中有变量定义在其他模块， 该怎么办？事实上，定义其他模块的全局变量和函数在最终运行时的绝对地址都要在最终链接的时候才能确定。所以现代的编译器可以将一个源代码文件编译成一个未链接的目标文 件，然后由链接器最终将这些目标文件链接起来形成可执行文件。让我们带着这个问题，走进链接的世界。

4.链接

　　链接：

　　程序没计的模块化是人们一直在追求的目标，因为当一个系统十分复杂的时候，我们不得不将一个复杂的系统逐步分割成小的系统以达到各个突破的目的。一个复杂的软件也如 此，人们把毎个源代码模块独立地编译，然后按照须要将它们“组装”起来，这个组装模块的过程就是链接

　　链接的主要内容就是把各个模块之间相互引用的部分都处理好， 使得各个模块之间能够正确地衔接。　　

　　gcc下的命令是： gcc test.o  ,然后我们会发现，路径底下多了一个叫a.out的文件，这就相当于我们的exe文件，我们可以 ./a.out 来运行它，看是否是我们想要的结果。

　　而它又在这个过程干了什么呢？

　　　　1.合并段表

　　　　　　我们在上方提到，汇编之后就会生成相应的 .o 文件，而这个 .o 文件又被分为几个段，在链接过程中就会把相同的段通过某种规则合并起来。

　　　　2.符号表的合并和定位

　　　　　　将所有文件的符号汇总在一起，在配上相应的地址。

　　　　3.重定位

　　若不同源文件出现了相同的符号，比如说我们在一个源文件里定义一个函数，在另一个源文件里用extern来声明这个函数，所以在符号表汇总的时候会出现两个此函数的符号，但应其中一个是非法地址（如extern的那个）所以最终只留下一个此符号。

　　　也就是说，在链接过程中，会把目标文件和链接库（库函数信息）链接起来，最后生成可执行程序。

　　　注意：

　　　　　　比如所，我们使用了一个我们并未定义的函数，而编译器就是在这一步才能看到错误。

5.总结

　　这便是程序的翻译环境，再来简练一下：

1. 预处理 选项 gcc -E test.c -o test.i 预处理完成之后就停下来，预处理之后产生的结果都放在test.i文件中。

2. 编译 选项 gcc -S test.c 编译完成之后就停下来，结果保存在test.s中。

3. 汇编 gcc -c test.c 汇编完成之后就停下来，结果保存在test.o中。

二.程序的运行环境

程序执行的过程：

1. 程序必须载入内存中。在有操作系统的环境中：一般这个由操作系统完成。在独立的环境中，程序的载入必须 由手工安排，也可能是通过可执行代码置入只读内存来完成。

2. 程序的执行便开始。接着便调用main函数。

3. 开始执行程序代码。这个时候程序将使用一个运行时堆栈（stack），存储函数的局部变量和返回地址。程序同 时也可以使用静态（static）内存，存储于静态内存中的变量在程序的整个执行过程一直保留他们的值。

4. 终止程序。正常终止main函数；也有可能是意外终止。

----参考：《程序员的自我修养——链接、装载与库》

|------------------------------------------------------------------

到此，对于程序的运行环境的简易了解便到此结束!

因笔者水平有限，若有错误，还望指正！

词法分析产生的记号一般可以分为如下几类：关键字、标识符、字面量（包含数字、字 符串等）和特殊符号（如加号、等号〉。在识别记号的同时，扫描器也完成了其他工作。比 如将标识符存放到符号表，将数字、字符串常景存放到文字表等，以备后面的步骤使用。有一个叫做lex的程序可以实现同法扫描，它会按照用户之前描述好的词法规则将输入 的字符串分割成一个个记号。因为这样-个程序的存在，编译器的开发者就无须为每个编译 器开发•个独立的词法扫描器，而是根据需要改变词法规则就可以了。另外对T一些有预处理的语言，比如C语言，它的宏替换和文件包含等T作一般不归 入编译器的范围而交给一个独立的预处理器。

C语言之简易了解程序环境的更多相关文章

  1. 利用Scala语言开发Spark应用程序

    Spark内核是由Scala语言开发的,因此使用Scala语言开发Spark应用程序是自然而然的事情.如果你对Scala语言还不太熟悉,可 以阅读网络教程A Scala Tutorial for Ja ...

  2. J2msi 自己制作的把exe打成安装包简易GUI程序(第二版 带DLL注册)

    J2msi 自己制作的把exe打成安装包简易GUI程序(第二版 带DLL注册) 之前那一版本(http://www.cnblogs.com/rojas/p/4794684.html)没考虑 DLL 注 ...

  3. Golang (Go语言) Mac OS X下环境搭建 环境变量配置 开发工具配置 Sublime Text 2 【转】

    一.安装Golang的SDK 在官网 http://golang.org/ 直接下载安装包安装即可.下载pkg格式的最新安装包,直接双击运行,一路按照提示操作即可完成安装. 安装完成后,打开终端,输入 ...

  4. C语言实现简易计算器(可作加减乘除)

    C语言实现简易计算器(加减乘除) 计算器作为课设项目,已完成答辩,先将代码和思路(注释中)上传一篇博客 已增添.修改.整理至无错且可正常运行 虽使用了栈,但初学者可在初步了解栈和结构语法后理解代码 # ...

  5. 基于php基础语言编写的小程序之计算器

    基于php基础语言编写的小程序之计算器 需求:在输入框中输入数字进行加.减.乘.除运算(html+php) 思路: 1首先要创建输入数字和运算符的输入框,数字用input的text属性,运算符用sel ...

  6. JavaScript简易缩放程序

    一.前言: 上一篇随笔中已经把拖动程序完成了,这篇主要把缩放程序完成,后面合并后可以做成一个图片裁剪的功能 简易缩放程序DEMO:http://jsfiddle.net/UN99R/ 限制缩放程序DE ...

  7. SAS进阶《深入解析SAS》之开发多语言支持的SAS程序

    SAS进阶<深入解析SAS>之开发多语言支持的SAS程序 1. 多语言支持的应用程序是指该程序在世界给第使用时,其能够处理的数据,以及处理数据的方式.信息展现的方式都符合当地的语言.文化习 ...

  8. 小程序内嵌H5页面判断微信及小程序环境

    判断微信及小程序环境 1.H5页面引入jweixin-1.3.2.js 2. var ua = window.navigator.userAgent.toLowerCase(); if(ua.matc ...

  9. [转载] 使用C/C++语言编写基于DSP程序的注意事项

    原文地址:『转』使用C/C++语言编写基于DSP程序的注意事项作者:skysmile   1.不影响执行速度的情况下,可以使用c或c/c++语言提供的函数库,也可以自己设计函数,这样更易于使用“裁缝师 ...

随机推荐

  1. WebAssembly in Action

    WebAssembly in Action 数据加密,反爬虫,防盗链,版权保护,数据追踪,埋点 blogs 加密,js 禁用检测,权限控制 WebAssembly 防盗链 wasm online id ...

  2. Flutter framework & Flutter basics

    Flutter framework & Flutter basics https://flutter.dev/docs/get-started/learn-more UI widgets ht ...

  3. GitHub Actions

    GitHub Actions CI/CD & testing https://github.com/features/actions refs xgqfrms 2012-2020 www.cn ...

  4. vue页面切换过渡

    <!--<transition name="slide-left">--> <router-view></router-view>& ...

  5. 算法型稳定币USDN有什么魔力引发市场热潮？

    最近比特币重新突破了8万大关,区块链行业又再次火爆起来,吸引了圈内圈外人的火热讨论,而这其中市场投资者讨论最频繁的就要属算法型稳定币USDN了. USDN是基于NGK.IO区块链中的稳定币, 1枚US ...

  6. MySQL学习04（DQL查询）

    DQL查询 DQL语言 DQL( Data Query Language 数据查询语言 ) 查询数据库数据 , 如SELECT语句 简单的单表查询或多表的复杂查询和嵌套查询 是数据库语言中最核心,最重 ...

  7. css优先级和权重

    1. 权重概念: 权重,是一个相对的概念,是针对某一指标而言.某一指标的权重是指该指标在整体评价中的相对重要程度. 权重系数,是表示某一指标项在指标项系统中的重要程度,它表示在其它指标项不变的情况下, ...

  8. MySQL应用优化

    MySQL应用优化 目录 MySQL应用优化 1.数据库连接池 2.减少对MySQL的访问 3.负载均衡 4.MySQL查询缓存优化 5.MySQL如何使用缓存 6.MySQL内存管理以及优化 原则 ...

  9. Go的map

    目录 map 一.map的创建 1.map的类型 2.定义并初始化 二.给map添加元素 三.获取map的元素 四.删除map的元素 五.获取map的长度 六.map的类型 七.map的相等性 八.循 ...

  10. docker ssh秘钥免密登录

    一.概述 有一台跳板机,已经实现了免密登录后端服务器.但是我写了一个django项目,它是运行在容器中的,也需要免密登录后端服务器. 虽然可以在容器中手动做一下免密登录,但是容器重启之后,之前做的设置 ...