linux编译cmakefile

『壹』 如何用GCC在linux下编译C语言程序

在Linux下面,如果要编译一个C语言源程序,我们要使用GNU的gcc编译器，假设我们有下面一个非常简单的源程序(hello.c):

int main(int argc,char **argv)

{

printf("Hello Linux ");

}

要编译这个程序,我们只要在命令行下执行:

gcc -o hello hello.c

gcc 编译器就会为我们生成一个hello的可执行文件.执行./hello就可以看到程
序的输出结果了

『贰』 linux内核模块编译-通过Makefile重命名.ko文件名和模块名

假设模块的源文件为hello.c，源码如下：

使用该文件编译内核模块。
正常情况下，Makefile文件内容如下：

执行 make 命令，生成hello.ko文件。
执行 sudo insmod hello.ko 命令，安装该模块。
执行 lsmod 命令，查看安装的模块。就会看到第一行的就是hello模块。

但是，如果想自定义模块名称为 xmole ，而不是默认的 hello ，如何实现呢？方法如下：
在Makefile中重命名obj-m并将obj-m的依赖关系设置为原始模块(hello)
修改后的Makefile文件内容如下：

将obj-m设置为 xmole .o，并使 xmole .o依赖于 hello .o.
执行 make 命令后，生成 xmole .ko, 而不是 hello .ko，
安装命令: sudo insmod xmole.ko
查看命令： lsmod ，就会看到被安装名为 xmole 的模块。

『叁』 linux中用C语言编写完模块后怎么编写makefile文件

1、先写Makefile编译出***.ko文件
模板如下，保存到命名为Makefile文件里，放到你代码专的同级目录下
TARGET=my_proc.ko
LINUXDIR=/lib/moles/$(shell uname -r)/build
PWD=$(shell pwd)
obj-m :=
obj-m += my_proc.o

all: $(TARGET)
$(TARGET): $(OBJS)
make -C $(LINUXDIR) SUBDIRS=$(PWD) moles
clean:
rm -f moles.order Mole.symvers $(TARGET) *.mod.c *.o
rm -rf .tmp_versions .mod* Mole.markers
2、属make
3、root权限下用命令插入模块
insmod my_proc.ko
4、可以用你写的应用程序打开、操作模块了
5、查看模块命令
lsmod
cat /proc/moles
modinfo my_proc.ko
6、root下卸载模块
rmmod

『肆』 [Linux]编写一个简单的C语言程序，编写Makefile文件。

//calculate.h
#ifndef DEFCALCULATE_H
#define DEFCALCULATE_H
#include <string>
#include <map>
#include <iostream>
#include <cctype>
using namespace std;
// =========================================================================
// = 一些标志，如数字、+-*/()
enum Token_value
{
NAME,
NUMBER,
END,
PLUS='+',
MINUS='-',
MUL='*',
DIV='/',
PRINT=';',
ASSIGN='=',
LP='(',
RP=')'
};
//#############################################################################
//#############################################################################
double term(bool); //乘法
double prim(bool); //处理初等项
double error(const string&); //错误函数
Token_value get_token(); //输入
double expr(bool get); //加和减
//#############################################################################
//#############################################################################
extern double number_value; //
extern string string_value; //
extern Token_value curr_tok; //当前操作标志
extern map<string,double> table;//
extern int no_of_errors; //
#endif

//winconsole.cpp
#include "calculate.h"
#include <sstream>
istream* input;
int main()
{
//switch(argc)
//{
//case 1:
input=&cin;
// break;
//case 2:
// input=new istringstream(argv[1]);
// break;
//default:
// error("too many arguments");
// return 1;
//}
table["pi"]=3.14159;
table["e"]=2.718182;
while (*input)
{
get_token();
if (curr_tok==END)
{
break;
}
if (curr_tok==PRINT)
{
continue;
}
cout<<expr(false)<<endl;
}
if (input!=&cin)
{
delete input;
}
return 0;
}
//error.cpp
#include "calculate.h"
int no_of_errors;
double error(const string& s)
{
no_of_errors++;
cerr<<"error:"<<s<<'\n';
return 1;
}
//expr.cpp
#include "calculate.h"
Token_value curr_tok=PRINT;
double expr(bool get)//加和减
{
double left=term(get);
for (;;)
{
switch(curr_tok)
{
case PLUS:
left+=term(true);
break;
case MINUS:
left-=term(true);
break;
default:
return left;
}
}
}
//get_token.cpp
#include "calculate.h"
extern Token_value curr_tok;
Token_value get_token()
{
char ch=0;
cin>>ch;
switch(ch)
{
case 0:
return curr_tok=END;
case ';':
case '*':
case '/':
case '+':
case '-':
case '(':
case ')':
case '=':
return curr_tok=Token_value(ch);
case '0':case '1':case '2':case '3':case '4':
case '5':case '6':case '7':case '8':case '9':
case '.':
cin.putback(ch);
cin>>number_value;
return curr_tok=NUMBER;
default:
if (isalpha(ch))
{
cin.putback(ch);
cin>>string_value;
return curr_tok=NAME;
}
error("bad token");
return curr_tok=PRINT;
}
}
//prim.cpp
#include "calculate.h"
double number_value;
string string_value;
map<string,double> table;
double prim(bool get)
{
if (get)
{
get_token();
}
switch(curr_tok)
{
case NUMBER:
{
double v=number_value;
get_token();
return v;
}
case NAME:
{
double& v=table[string_value];
if (get_token()==ASSIGN)
{
v=expr(true);
}
return v;
}
case MINUS:
{
return -prim(true);
}
case LP:
{
double e=expr(true);
if (curr_tok!=RP)
{
return error(")expected");
}
get_token();
return e;
}
default:
return error("primary expected");
}
}
//term.cpp
#include "calculate.h"
double term(bool get)
{
double left=prim(get);
for (;;)
{
switch(curr_tok)
{
case MUL:
left*=prim(true);
break;
case DIV:
if (double d=prim(true))
{
left/=d;
break;
}
return error("divide by 0");
default:
return left;
}
}
}
//makefile
objects = error.o expr.o get_token.o prim.o term.o winconsole.o
calculate:$(objects)
g++ -Wall -g -o calculate $(objects)
$(objects) : %.o : %.cpp
g++ -c $(CXXFLAGS) $< -o $@

//这是一个在linux下实现的简单的计算器程序，实现带括号的+-*/运算的，由于复制进来代码格式有点出入，你自己把代码格式规范下，尤其是makefile文件里的命令前面一定要以一个tab开始

『伍』 Linux中编写了内核模块的C源程序之后怎么编写makefile文件的内容

make命令执行时，需要一个 Makefile 文件，以告诉make命令需要怎么样的去编译和链接程序。

首先，我们用一个示例来说明Makefile的书写规则。以便给大家一个感兴认识。这个示例来源于GNU的make使用手册，在这个示例中，我们的工程有8个C文件，和3个头文件，我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。我们的规则是：
1）如果这个工程没有编译过，那么我们的所有C文件都要编译并被链接。
2）如果这个工程的某几个C文件被修改，那么我们只编译被修改的C文件，并链接目标程序。
3）如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的C文件，并链接目标程序。

只要我们的Makefile写得够好，所有的这一切，我们只用一个make命令就可以完成，make命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自己编译所需要的文件和链接目标程序。

一、Makefile的规则

在讲述这个Makefile之前，还是让我们先来粗略地看一看Makefile的规则。

target ... : prerequisites ...
command
...
...

target也就是一个目标文件，可以是Object File，也可以是执行文件。还可以是一个标签（Label），对于标签这种特性，在后续的“伪目标”章节中会有叙述。

prerequisites就是，要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。（任意的Shell命令）

这
是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在command中。说
白一点就是说，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。这就是
Makefile的规则。也就是Makefile中最核心的内容。

说到底，Makefile的东西就是这样一点，好像我的这篇文档也该结束了。呵呵。还不尽然，这是Makefile的主线和核心，但要写好一个Makefile还不够，我会以后面一点一点地结合我的工作经验给你慢慢到来。内容还多着呢。：）

二、一个示例

正如前面所说的，如果一个工程有3个头文件，和8个C文件，我们为了完成前面所述的那三个规则，我们的Makefile应该是下面的这个样子的。

edit : main.o kbd.o command.o display.o /
insert.o search.o files.o utils.o
cc -o edit main.o kbd.o command.o display.o /
insert.o search.o files.o utils.o

main.o : main.c defs.h
cc -c main.c
kbd.o : kbd.c defs.h command.h
cc -c kbd.c
command.o : command.c defs.h command.h
cc -c command.c
display.o : display.c defs.h buffer.h
cc -c display.c
insert.o : insert.c defs.h buffer.h
cc -c insert.c
search.o : search.c defs.h buffer.h
cc -c search.c
files.o : files.c defs.h buffer.h command.h
cc -c files.c
utils.o : utils.c defs.h
cc -c utils.c
clean :
rm edit main.o kbd.o command.o display.o /
insert.o search.o files.o utils.o

反
斜杠（/）是换行符的意思。这样比较便于Makefile的易读。我们可以把这个内容保存在文件为“Makefile”或“makefile”的文件中，
然后在该目录下直接输入命令“make”就可以生成执行文件edit。如果要删除执行文件和所有的中间目标文件，那么，只要简单地执行一下“make
clean”就可以了。

在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（*.o），依赖文件
（prerequisites）就是冒号后面的那些 .c 文件和 .h文件。每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件
edit 的依赖文件。依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。

在定义好依赖关系
后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个Tab键作为开头。记住，make并不管命令是怎么工作的，他只管执行所定义的命
令。make会比较targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期要比targets文件的
日期要新，或者target不存在的话，那么，make就会执行后续定义的命令。

这里要说明一点的是，clean不是一个文件，它只不过
是一个动作名字，有点像C语言中的lable一样，其冒号后什么也没有，那么，make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。
要执行其后的命令，就要在make命令后明显得指出这个lable的名字。这样的方法非常有用，我们可以在一个makefile中定义不用的编译或是和编
译无关的命令，比如程序的打包，程序的备份，等等。

『陆』 linux下编写简单的makefile的报错

如果真的 简单，就不用 makefile
一个命令行
gcc -o hello hello.c
gcc 编译 hello.c 文件，目标 文件 hello