c编译器代码（没有编译器怎么运行代码）

今天给各位分享c编译器代码的知识，其中也会对没有编译器怎么运行代码进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、如何编译C语言源代码
• 2、用gcc编译器C语言程序的技巧
• 3、手机版c语言编译器爱心代码怎么用
• 4、C语言编译器是什么？
• 5、c语言编译器如何运行
• 6、求哈夫曼编译器 C语言代码

如何编译C语言源代码

1、以GCC编译器为例，可以分为四步。

第一步是预处理，包括语法检查等工作。

gcc -P abc.c

第二步由源程序生产汇编语言代码。

gcc -S abc.c

会生成abc.s文件，这个文件里就是汇编代码。

第三步编译器生成目标代码，一个源文件生成一个目标代码。

gcc -c abc.c

会生成abc.o

第四步连接器从目标代码生成可执行文件。

gcc abc.o

2、目标代码包括机器码和符号表（函数及变量名）。连接器的主要作用是通过符号表在库文件和其他模块中找到在目标代码中引入或未定义的符号（函数及变量名），将几个目标代码合成可执行文件。

用gcc编译器C语言程序的技巧

方法/步骤

1、编写c代码，并输入以下代码，生成文件hello.c

[root@wahoo

test]#

vim

hello.c

#include

stdio.h

#define

DISPLAY

"hello

c!"

int

main(void)

{

printf("%s\n",

DISPLAY

);

return

0;

}

ZZ（说明：ZZ当前文件进行快速保存操作）

2、预编译(Preprocessing)

会对各种预处理指令（#include

#define

#ifdef

等#开始的代码行）进行处理，删除注释和多余的空白字符，生成一份新的代码

[root@wahoo

test]#gcc

-E

hello.c

-o

hello.i

E

参数

通知gcc对目标文件进行预编译，这里是对文件hello.c文件

o

参数

是对命令输出结果进行导入操作，这里是把

gcc

-E

hello.c

操作结果输出到文件hello.i（命名要自定义）中进行保存

这个命令执行完后我们目录下多了一个文件hello.i，你可以查阅一下文件的内容。

3、编译(Compilation)

对代码进行语法、语义分析和错误判断，生成汇编代码文件

[root@wahoo

test]#gcc

-S

hello.i

-o

hello.s

S

参数

通知gcc对目标文件进行编译，这里是对文件hello.i文件

通过这一步我们知道

C语言跟汇编的

关系，至于他们之前是如何进行转换的，大家可以进行更深入的学习与探讨。

此时目录下多了一个hello.s文件，内容如图

4、汇编(Assembly)

把汇编代码转换与计算机可认识的二进制文件，要知道计算机只认识0和1呢

[root@wahoo

test]#gcc

-c

hello.s

-o

hello.o

c

参数

通知gcc对目标文件执行指令转换操作

此步骤我们得到文件hello.o

大家也同样打开文件查看一下，这个文件里面几乎没几个字符大家能看懂，这就对了，但大家可以通过这种方法将其转化为我们可读的形式：

[root@wahoo

test]#readelf

-a

hello.o

5、链接(Linking/Build)

通俗的讲就是把多个*.o文件合并成一个可执行文件，二进制指令文件

[root@wahoo

test]#gcc

hello.o

-o

hello

这里我们就得到了一个可以直接在系统下执行的文件

hello

我们也可以对这个文件进行readelf操作，也可以进行二进制指令转汇编的操作

[root@wahoo

test]#objdump

-d

hello

6、程序运行

[root@wahoo

test]#./hello

hello

c!

7、总结：gcc

编译c程序的主要过程包括

预编译-编译-汇编-连接

四个过程，每个过程都分别进行不同的处理，了解了这其中的一些原理，对c编程的理解大有益处

手机版c语言编译器爱心代码怎么用

include

#include

void put_ch(char ch,int a,int b)//在a个空格后，显示b个字符ch

int i;

for(i=0;i

printf("%c",' ');//printf(" ");

for(i=0;i

printf("%c",ch);

int main (void)

int a,b,c;

C语言编译器是什么？

C语言是一门面向过程的计算机编程语言，与C++、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。C语言描述问题比汇编语言迅速，工作量小、可读性好，易于调试、修改和移植，而代码质量与汇编语言相当。C语言一般只比汇编语言代码生成的目标程序效率低10%～20%。因此，C语言可以编写系统软件。[2]

二十世纪八十年代，美国国家标准局为了避免各开发厂商用的C语言语法产生差异，给C语言制定了一套完整的美国国家标准语法，称为ANSI C。作为C语言最初的标准。[3]2011年12月8日，国际标准化组织（ISO）和国际电工委员会（IEC）发布的C11标准是C语言的第三个官方标准，也是C语言的最新标准，该标准更好的支持了汉字函数名和汉字标识符，一定程度上实现了汉字编程。

C语言编译器普遍存在于各种不同的操作系统中，例如Microsoft Windows, Mac OS X, Linux, Unix等。C语言的设计影响了众多后来的编程语言，例如C++、Objective-C、Java、C#等。

例:

#include stdio.h

int main() {

printf("Hello,world!");

return 0;

}

编译运行将输出: Hello,world!

c语言编译器如何运行

编译共分为四个阶段：预处理阶段、编译阶段、汇编阶段、链接阶段。

1、预处理阶段：

主要工作是将头文件插入到所写的代码中，生成扩展名为“.i”的文件替换原来的扩展名为“.c”的文件，但是原来的文件仍然保留，只是执行过程中的实际文件发生了改变。（这里所说的替换并不是指原来的文件被删除）

2、汇编阶段：

插入汇编语言程序，将代码翻译成汇编语言。编译器首先要检查代码的规范性、是否有语法错误等，以确定代码的实际要做的工作，在检查无误后，编译器把代码翻译成汇编语言，同时将扩展名为“.i”的文件翻译成扩展名为“.s”的文件。

3、编译阶段：

将汇编语言翻译成机器语言指令，并将指令打包封存成可重定位目标程序的格式,将扩展名为“.s”的文件翻译成扩展名为“.o”的二进制文件。

4、链接阶段：

在示例代码中，改代码文件调用了标准库中printf函数。而printf函数的实际存储位置是一个单独编译的目标文件（编译的结果也是扩展名为“.o”的文件），所以此时主函数调用的时候，需要将该文件（即printf函数所在的编译文件）与hello world文件整合到一起，此时链接器就可以大显神通了，将两个文件合并后生成一个可执行目标文件。

求哈夫曼编译器 C语言代码

// huffman.cpp : Defines the entry point for the console application.

//

#include iostream.h

#include stdio.h

#include string.h

const long wordnum = 1000;//最大不同单词数

const long code_len = wordnum/10;

const long wordlen = 30;//单词最长长度

const long codemax = 10000;//最大haffuman编码长度

const long wordmax = 10000;//最大单词数

//str类定义

class str

{

public:

str();

bool operator(str obj);//运算符重载方便对str的排序使用二分搜索模板

bool operator(str obj);

str operator=(char p[]);

str operator++(int);//重载后缀方式的＋＋

char *getword();

long getfre();

protected:

private:

char word[wordlen];

long frequence;

};

str::str()

{

frequence = 0;

}

//以下为重载str类中的运算符

bool str::operator(str obj)

{

if(strcmp(word,obj.word) 0)

return true;

else

return false;

}

bool str::operator(str obj)

{

if(strcmp(word,obj.word) 0)

return true;

else

return false;

}

str str::operator=(char p[])

{

strcpy(word,p);

return *this;

}

str str::operator++(int x)

{

frequence ++;

return *this;

}

char * str::getword()

{

return word;

}

long str::getfre()

{

return frequence;

}

//str类定义结束

//Node类定义

class Node

{

public:

Node();

bool operator(Node obj);//运算符重载方便对Node的排序使用堆模板

bool operator=(Node obj);

bool operator(Node obj);

Node operator=(str obj);

Node operator+(Node obj);

Node *leftp();//类外获取指向当前节点的孩子的指针

Node *rightp();

char *getword(Node *p);//类外获取节点信息

long getfrequence();

protected:

private:

char word[wordlen];

long frequence;

Node *left, *right;

};

Node::Node()

{

strcpy(word,"NULL");

left = NULL;

right = NULL;

}

//以下为重载Node类中的运算符

bool Node::operator(Node obj)

{

if(frequence obj.frequence)

return true;

else

return false;

}

bool Node::operator=(Node obj)

{

if(frequence = obj.frequence)

return true;

else

return false;

}

bool Node::operator(Node obj)

{

if(frequence obj.frequence)

return true;

else

return false;

}

Node Node::operator+(Node obj)

{

Node sum;

sum.frequence = frequence + obj.frequence;//指针指向了NULL

sum.left = this;

sum.right = obj;

return sum;

}

Node Node::operator=(str obj)

{

strcpy(word,obj.getword());

frequence = obj.getfre();

return *this;

}

Node * Node::leftp()

{

return left;

}

Node * Node::rightp()

{

return right;

}

char * Node::getword(Node *p)

{

return p-word;

}

long Node::getfrequence()

{

return frequence;

}

//Node类定义结束

//str类专门用于统计词频使用，Node则用于构造huffman树，由于两者使用的key不同，前者是word的字典序

//后者是词频，于是使用了两个类来实现。

class huffman

{

public:

huffman();

templatetypename entry

friend bool binarysearch(entry list[wordnum],entry target,long bottom,long top,long position);

templatetypename entry

friend void buidheap(entry a[wordnum], long number);

templatetypename entry

friend void heapify(entry a[wordnum], long high, long low);

templatetypename entry

friend void swap(entry a[wordnum], long i, long j);

bool Stat();

void Encode();

bool Decode(char code[]);

Node update(long end);

void produce_code();

void Inorder(Node *current, char currentcode[], long num);

protected:

private:

Node SortedNode[wordnum];//从中产生huffman树

char NodeCode[wordnum][wordnum/10];//相应编码

Node root;

bool sign;//用于标记是否已经建立了huffman树

long n;//叶子节点个数

};

huffman::huffman()

{

sign = false;

}

//二分用于统计词频

templatetypename entry

bool binarysearch(entry list[wordnum], entry target, long bottom, long top, long position)

{

while(bottom = top)

{

position = (bottom + top)/2;

if(list[position] target)

bottom = position + 1;

else if(list[position] target)

top = position - 1;

else

return true;

}

return false;

}

//建立最小堆及调整为最小堆

templatetypename entry

void swap(entry a[wordnum], long i, long j)

{

entry s;

s = a[i];

a[i] = a[j];

a[j] = s;

}

templatetypename entry

void buidheap(entry a[wordnum], long number)

{

long i ,j;

for(i = number/2; i = 1; i--)

{

j = i;

while(j = number/2)

{

if(a[j] a[2*j] || (a[j] a[2*j + 1] 2*j + 1 = number))

{

if(a[2*j] a[2*j + 1] 2*j + 1 = number)

{

swap(a, j, 2*j+1);

j = 2*j + 1;

}

else

{

swap(a, j ,2*j);

j = 2*j;

}

}

else

break;

}

}

}

templatetypename entry

void heapify(entry a[wordnum], long high, long low)

{

long j = low;

while(j = high/2)

{

if(a[j] a[2*j] a[j] a[2*j + 1])

{

if(a[2*j] a[2*j + 1] 2*j + 1 = high)

{

swap(a, j, 2*j+1);

j = 2*j + 1;

}

else if(2*j = high)

{

swap(a, j, 2*j);

j = 2*j;

}

}

else if(a[j] = a[2*j] a[j] a[2*j + 1] 2*j + 1 = high)

{

swap(a, j, 2*j+1);

j = 2*j + 1;

}

else if(a[j] = a[2*j + 1] a[j] a[2*j] 2*j = high)

{

swap(a, j, 2*j);

j = 2*j;

}

else

break;

}

}

//词频统计函数Stat()

bool huffman::Stat()

{

long i,position;

char p[wordmax],*get;

str s[wordnum],current;

n = 0;

while(gets(p) != NULL strcmp(p,"@") != 0)

{

get = strtok(p," ,.!/-:;?");

while(get != NULL)

{

current = get;

if(binarysearch(s,current,0,n,position) == true n wordnum - 1)

s[position] ++;

else

{

n ++;

if(n wordnum - 1)

{

if(s[position] current current.getfre() s[position].getfre())

position ++;

for(i = n; i = position; i --)

s[i+1] = s[i];

s[position] = current;

s[position] ++;

}

}

get = strtok(NULL," ,.!/-:;?");

}

}

for(i = 1; i = n i wordnum; i ++)

SortedNode[i] = s[i-1];

if(n wordnum)

return true;

else

{

n = wordnum - 1;

return false;

}

}

//建立huffman树函数

void huffman::Encode()

{

int i;

sign = true;

buidheap(SortedNode,n);

for(i = 1; i n; i ++)

root = update(n-i+1);

}

Node huffman::update(long end)

{

Node *p,*q;

Node newNode;

p = new Node;

q = new Node;

*p = SortedNode[1];

swap(SortedNode,1,end);

heapify(SortedNode,end-1,1);//取出了一个最小元，然后将堆进行了调整

*q = SortedNode[1];

newNode = *p + *q;

SortedNode[1] = newNode;

heapify(SortedNode,end-1,1);//又取出最小元，并且把新节点赋为SortedNode[1]，调整了堆

return SortedNode[1];

}

//解码函数

bool huffman::Decode(char code[codemax])

{

int i;

Node *find = root;

Node *l = NULL,*r = NULL;

bool flag = true;

if(sign == true)

{

for(i = 0; code[i] != '\0' flag == true; i ++)

{

l = find-leftp();

r = find-rightp();

if(code[i] == '0' l != NULL)

find = l;

else if(code[i] == '1' r != NULL)

find = r;

else flag = false;

if(find-leftp() == NULL find-rightp() == NULL)

{

printf("%s ",find-getword(find));

find = root;

}

}

if(!((find-leftp() == NULL find-rightp() == NULL) || find == root))

{

cout "There are some wrong codes in th input!" endl;

flag = false;

}

}

else

flag = false;

return flag;

}

void huffman::Inorder(Node *current, char currentcode[], long num)

{

Node *l, *r;

char cl[code_len], cr[code_len];

if(current != NULL)

{

l = current-leftp();

r = current-rightp();

strcpy(cl,currentcode);

strcat(cl,"0");

strcpy(cr,currentcode);

strcat(cr,"1");

Inorder(l, cl, num);

if(l == NULL r == NULL)

{

SortedNode[num] = *current;

strcpy(NodeCode[num],currentcode);

num ++;

}

Inorder(r, cr, num);

}

}

void huffman::produce_code()//利用中序遍历来得到相应的编码

{

char current[code_len] = "";

long num = 1;

Inorder(root, current,num);

for(long i = 1; i = n; i ++)

{

cout SortedNode[i].getword(SortedNode[i]) "----" NodeCode[i]" " ;

if(i%3 == 0) cout endl;

}

}

int main()

{

huffman test;

char code[codemax];

char order;

cout "显示编码(Show)" " " "解码(Decode)" " " "退出(Quit)" endl;

cout "Input the passage, to end with a single @ in a single line:" endl;

test.Stat();

test.Encode();

cout "Encoded!" endl;

while(cin order)

{

if(order == 's' || order == 'S')

{

test.produce_code();

cout "Produced!" endl;

}

else if(order == 'd' || order == 'D')

{

cout "Input the codes:" endl;

cin code;

while(test.Decode(code))

cin code;

}

else if(order == 'q' || order == 'Q')

break;

}

return 0;

}

c编译器代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于没有编译器怎么运行代码、c编译器代码的信息别忘了在本站进行查找喔。