A. 怎样学习在linux操作系统下用c语言编程
这篇文章介绍在LINUX下进行C语言编程所需要的基础知识.在这篇文章当中,我们将会学到以下内容:
源程序编译
Makefile的编写
程序库的链接
程序的调试
头文件和系统求助
--------------------------------------------------------------------------------
1.源程序的编译
在Linux下面,如果要编译一个C语言源程序,我们要使用GNU的gcc编译器. 下面我们以一个实例来说明如何使用gcc编译器.
假设我们有下面一个非常简单的源程序(hello.c):
int main(int argc,char **argv)
{
printf("Hello Linux\n");
}
要编译这个程序,我们只要在命令行下执行:
gcc -o hello hello.c
gcc 编译器就会为我们生成一个hello的可执行文件.执行./hello就可以看到程序的输出结果了.命令行中
gcc表示我们是用gcc来编译我们的源程序,-o 选项表示我们要求编译器给我们输出的可执行文件名为hello
而hello.c是我们的源程序文件. gcc编译器有许多选项,一般来说我们只要知道其中的几个就够了. -o选项我们已经知道了,表示我们要求输出的可执行文件名.
-c选项表示我们只要求编译器输出目标代码,而不必要输出可执行文件. -g选项表示我们要求编译器在编译的时候提供我们以后对程序进行调试的信息. 知道了这三个选项,我们就可以编译我们自己所写的简单的源程序了,如果你想要知道更多的选项,可以查看gcc的帮助文档,那里有着许多对其它选项的详细说明.
2.Makefile的编写
假设我们有下面这样的一个程序,源代码如下:
/* main.c */
#include "mytool1.h"
#include "mytool2.h"
int main(int argc,char **argv)
{
mytool1_print("hello");
mytool2_print("hello");
}
/* mytool1.h */
#ifndef _MYTOOL_1_H
#define _MYTOOL_1_H
void mytool1_print(char *print_str);
#endif
/* mytool1.c */
#include "mytool1.h"
void mytool1_print(char *print_str)
{
printf("This is mytool1 print %s\n",print_str);
}
/* mytool2.h */
#ifndef _MYTOOL_2_H
#define _MYTOOL_2_H
void mytool2_print(char *print_str);
#endif
/* mytool2.c */
#include "mytool2.h"
void mytool2_print(char *print_str)
{
printf("This is mytool2 print %s\n",print_str);
}
当然由于这个程序是很短的我们可以这样来编译
gcc -c main.c
gcc -c mytool1.c
gcc -c mytool2.c
gcc -o main main.o mytool1.o mytool2.o
这样的话我们也可以产生main程序,而且也不时很麻烦.但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)
那么我们难道还要重新输入上面的命令?也许你会说,这个很容易解决啊,我写一个SHELL脚本,让她帮我去完成不就可以了.是的对于这个程序来说,是可以
起到作用的.但是当我们把事情想的更复杂一点,如果我们的程序有几百个源程序的时候,难道也要编译器重新一个一个的去编译? 为此,聪明的程序员们想出了一个很好的工具来做这件事情,这就是make.我们只要执行以下make,就可以把上面的问题解决掉.在我们执行
make之前,我们要先编写一个非常重要的文件.--Makefile.对于上面的那个程序来说,可能的一个Makefile的文件是: # 这是上面那个程序的Makefile文件
main:main.o mytool1.o mytool2.o
gcc -o main main.o mytool1.o mytool2.o
main.o:main.c mytool1.h mytool2.h
gcc -c main.c
mytool1.o:mytool1.c mytool1.h
gcc -c mytool1.c
mytool2.o:mytool2.c mytool2.h
gcc -c mytool2.c
有了这个Makefile文件,不过我们什么时候修改了源程序当中的什么文件,我们只要执行make命令,我们的编译器都只会去编译和我们修改的文件有关的文件,其它的文件她连理都不想去理的.
下面我们学习Makefile是如何编写的.
在Makefile中也#开始的行都是注释行.Makefile中最重要的是描述文件的依赖关系的说明.一般的格式是:
target: components
TAB rule
第一行表示的是依赖关系.第二行是规则.
比如说我们上面的那个Makefile文件的第二行
main:main.o mytool1.o mytool2.o
表示我们的目标(target)main的依赖对象(components)是main.o mytool1.o mytool2.o
当倚赖的对象在目标修改后修改的话,就要去执行规则一行所指定的命令.就象我们的上面那个Makefile第三行所说的一样要执行 gcc -o
main main.o mytool1.o mytool2.o 注意规则一行中的TAB表示那里是一个TAB键 Makefile有三个非常有用的变量.分别是$@,$^,$
int main(int argc,char **argv)
{
double value;
printf("Value:%f\n",value);
}
这个程序相当简单,但是当我们用 gcc -o temp temp.c 编译时会出现下面所示的错误.
/tmp/cc33Ky.o: In function `main':
/tmp/cc33Ky.o(.text+0xe): undefined reference to `log'
collect2: ld returned 1 exit status
出现这个错误是因为编译器找不到log的具体实现.虽然我们包括了正确的头文件,但是我们在编译的时候还是要连接确定的库.在Linux下,为了
使用数学函数,我们必须和数学库连接,为此我们要加入 -lm 选项. gcc -o temp temp.c
-lm这样才能够正确的编译.也许有人要问,前面我们用printf函数的时候怎么没有连接库呢?是这样的,对于一些常用的函数的实现,gcc编译器会自
动去连接一些常用库,这样我们就没有必要自己去指定了. 有时候我们在编译程序的时候还要指定库的路径,这个时候我们要用到编译器的
-L选项指定路径.比如说我们有一个库在 /home/hoyt/mylib下,这样我们编译的时候还要加上
-L/home/hoyt/mylib.对于一些标准库来说,我们没有必要指出路径.只要它们在起缺省库的路径下就可以了.系统的缺省库的路径/lib
/usr/lib /usr/local/lib 在这三个路径下面的库,我们可以不指定路径. 还有一个问题,有时候我们使用了某个函数,但是我们不知道库的名字,这个时候怎么办呢?很抱歉,对于这个问题我也不知道答案,我只有一个傻办
法.首先,我到标准库路径下面去找看看有没有和我用的函数相关的库,我就这样找到了线程(thread)函数的库文件(libpthread.a).
当然,如果找不到,只有一个笨方法.比如我要找sin这个函数所在的库. 就只好用 nm -o /lib/*.so|grep
sin>~/sin 命令,然后看~/sin文件,到那里面去找了.
在sin文件当中,我会找到这样的一行libm-2.1.2.so:00009fa0 W sin 这样我就知道了sin在
libm-2.1.2.so库里面,我用 -lm选项就可以了(去掉前面的lib和后面的版本标志,就剩下m了所以是 -lm).
如果你知道怎么找,请赶快告诉我,我回非常感激的.谢谢! 4.程序的调试
我们编写的程序不太可能一次性就会成功的,在我们的程序当中,会出现许许多多我们想不到的错误,这个时候我们就要对我们的程序进行调试了.
最常用的调试软件是gdb.如果你想在图形界面下调试程序,那么你现在可以选择xxgdb.记得要在编译的时候加入
-g选项.关于gdb的使用可以看gdb的帮助文件.由于我没有用过这个软件,所以我也不能够说出如何使用.
不过我不喜欢用gdb.跟踪一个程序是很烦的事情,我一般用在程序当中输出中间变量的值来调试程序的.当然你可以选择自己的办法,没有必要去学别人的.现
在有了许多IDE环境,里面已经自己带了调试器了.你可以选择几个试一试找出自己喜欢的一个用.
5.头文件和系统求助
有时候我们只知道一个函数的大概形式,不记得确切的表达式,或者是不记得着函数在那个头文件进行了说明.这个时候我们可以求助系统.
比如说我们想知道fread这个函数的确切形式,我们只要执行 man fread
系统就会输出着函数的详细解释的.和这个函数所在的头文件说明了. 如果我们要write这个函数的说明,当我们执行man
write时,输出的结果却不是我们所需要的.
因为我们要的是write这个函数的说明,可是出来的却是write这个命令的说明.为了得到write的函数说明我们要用 man 2 write.
2表示我们用的write这个函数是系统调用函数,还有一个我们常用的是3表示函数是C的库函数. 记住不管什么时候,man都是我们的最好助手.
--------------------------------------------------------------------------------
好了,这一章就讲这么多了,有了这些知识我们就可以进入激动人心的Linux下的C程序探险活动.
不积跬步,无以至千里!
B. Linux系统下C语言编译，显示时间(800分!)
/*
*
可以任意复制修改，scenbuffalo不负任何责任!
*
中文下的话，把nian换成年，yue换成月，ri换成日就行
*
我的linux不支持中文，只好用拼音代替。:)
*/
#include
<stdio.h>
#include
<unistd.h>
#include
<time.h>
int
main()
{
while
(1)
{
char
timebuf[100];
time_t
t;
time
(&t);
strftime(timebuf,
sizeof(timebuf),
"%Y
nian
%m
yue
%d
ri
%H:%M:%S",
localtime(&t));
printf
("%s\r",
timebuf);
fflush(stdout);
sleep(1);
}
return
0;
}
C. c语言设置linux系统时间
这个得打开rtc的驱动，然后在c里对驱动的设备文件进行修改操作。然后用hwclock -s同步硬件时钟。
D. Linux下C语言获得系统时间的方法
没有完整程序, 不过能提供一点资料
int gettimeofday(struct timeval * tv,struct timezone *tz);
这个函数可以获取当前时间, 貌似只要第一个结构体就行了
struct timeval
{
time_t tv_sec; //秒 [long int]
suseconds_t tv_usec; //微秒 [long int], (10E-6 second)
};
struct timeval
{
long tv_sec;
long tv_usec;
};
然后取微秒的前三位就是小数了, 之后把秒 tv_sec 转化为 tm 格式, 参数用秒的指针就行
struct tm * gmtime(const time_t * t);
//转换成格林威治时间。有时称为GMT或UTC。
struct tm * localtime(const time_t *t);
//转换成本地时间。它可以透过修改TZ环境变数来在一台机器中，不同使用者表示不同时间.
下面是tm的部分参数
int tm_sec; //tm_sec表“秒”数，在[0,61]之间，多出来的两秒是用来处理跳秒问题用的。/* Seconds: 0-59 (K&R says 0-61?) */
int tm_min; //tm_min表“分”数，在[0,59]之间。
int tm_hour; //tm_hour表“时”数，在[0,23]之间。
int tm_mday; //tm_mday表“本月第几日”，在[1,31]之间。
int tm_mon; //tm_mon表“本年第几月”，在[0,11]之间。
int tm_year; //tm_year要加1900表示那一年。 /* /* 年份，其值从1900开始 */*/
int tm_wday; //tm_wday表“本周第几日”，在[0,6]之间。 /* Days since Sunday (0-6) */ /*其中0代表星期天，1代表星期一，以此类推 */
int tm_yday; //tm_yday表“本年第几日”，在[0,365]之间，闰年有366日。 /*其中0代表1月1日，1代表1月2日，以此类推 */*/
int tm_isdst; //tm_isdst表是否为“日光节约时间”
------------------------------华丽丽的分割线--------------------------------------------------
由于很长时间没编程了, 也没有Linux环境, 我就简单写几行代码, 仅作参考
#include <stdio.h>
#include <time.h>
#include <sys/time.h>
#include<unistd.h>
//这四个不一定够用了
struct timeval tv;
struct timezone tz;
struct tm * p_tm;
//变量没有初始化习惯不好,不要学
gettimeofday(&tv, &tz);
p_tm = gmtime( (const time_t *)&tv.tv_sec );
字符串的组装尤其格式问题自己解决吧
年 p_tm->tm_year+ 1900
月 p_tm->tm_mon+ 1
日 p_tm->tm_mday
时 p_tm->tm_hour+ 1
分 p_tm->tm_min+ 1
秒 p_tm->tm_sec+ 1
小数点后面的部分,注意不够三位还是前面填充0 tv.tv_sec/1000
E. LINUX下C语言编程怎么打印日志
将日志写到文件中去，在到文件中去看日志
例如：
int
mig_log(fmt,va_alist)
char
*fmt
;
va_dcl
{
va_list
ap
;
FILE
*fp
;
char
log_file[81]
;
struct
tm
*p_tm
;
time_t
clock
;
ap=(char
*)&va_alist
;
time(&clock)
;
p_tm=localtime(&clock)
;
sprintf(log_file,"%s/mig_%4d%.2d%.2d.log",
getenv("HOME"),
p_tm->tm_year+1900,
p_tm->tm_mon+1,
p_tm->tm_mday)
;
fp=fopen(log_file,"at")
;
if(fp==(FILE
*)0)
{
fprintf(stderr,"mig_err_log():can't
open
the
file
%s
!\n",log_file);
return
;
}
fprintf(fp,"%.2d/%.2d/%4d
%.2d:%.2d:%.2d
",
p_tm->tm_mon+1,\
p_tm->tm_mday,\
p_tm->tm_year+1900,\
p_tm->tm_hour,\
p_tm->tm_min,\
p_tm->tm_sec)
;
vfprintf(fp,fmt,ap)
;
fclose(fp)
;
}
这个就是写日志的函数
你这样调用：mig_log("日志开始[%s]->[%d]\n",__FILE__,__LINE__)
;
mig_log("日志开始!\n")都可以的
F. linux下C语言怎么获取文件创建时间
在 Windows 下，一个文件有创建时间、修改时间、访问时间。而在 Linux 下，一个文件也有三种时间，分别是访问时间（Access）、修改时间（Modify）、状态改变时间（Change）。
可以使用 stat 命令查看文件的访问时间、修改时间和状态改变时间。
本人使用的机器的磁盘分区使用的文件系统类型是 ext3，也就是说本人是无法查看文件创建时间的。但是，如果文件创建后就没有修改过，修改时间=创建时间；如果文件创建后，状态就没有改变过，那么状态改变时间=创建时间；如果文件创建后，没有被读取过，那么访问时间=创建时间，当这个基本不太可能。
那什么时候访问时间，修改时间和状态改变时间会变化呢？比如我们使用vi打开文件但不编辑，那么退出后文件的访问时间就会改变；比如我们使用vi打开文件并且编辑后保存退出，那么文件的修改时间就会改变，当然访问时间也改变了；再比如使用chmod +x给文件增加可执行的属性，那么文件的状态改变时间就会改变。
【答题不易，请采纳谢谢】
G. C语言程序编程题。。。。请高手做下
这是在windows下的程序，用TC编译运行，完全可行。至于你的linux，我就不知道了。
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
1． 程序运行后，首先在屏幕上显示主菜单：
1． 查询某年某月某日是星期几
2． 查询某年是否是闰年
3． 打印某年的全年日历
4． 退出
2． 在主菜单中输入1后，显示：
“请输入年月日（XXXX，XX，XX）”
运行后输出：XXXX年XX月XX日是星期X，是否继续查询（Y/N）？
如果输入Y，则重新显示 “请输入年月日（XXXX，XX，XX）”，否则回到主菜单。
3． 在主菜单中输入2后，显示：
“请输入要查哪一年？（XXXX）”
运行后输出：XXXX年是（否）是闰年，是否继续查询（Y/N）？
如果输入Y，则重新显示，“请输入要查哪一年？（XXXX）”，否则回到主菜单。
4． 在主菜单中输入3后，显示：
“请输入要打印的年份（XXXX）”
运行后输出XXXX年的日历
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
一下是代码：
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define X " Sun Mon Tue Wed Thu Fri Sat"
void menu()
{
system("cls");
printf("\nTHIS IS THE MENU OF THE PROGRAM !");
printf("\nYOU CAN CHOOSE THE NUMBER FOR THE FUNCTIOM:");
printf("\n\n");
printf("1 Find the day by year-month-date.\n");
printf("2 Find the year you input if the leap year.\n");
printf("3 Print the calendar of the year you input.\n");
printf("4 Exit.\n\n");
printf("Input your choice:");
}
int getday(int year,int month,int date)
{
int flag,s,i;
int a[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
int cont=0;
flag=isleap(year);
if(flag==1)
a[2]++;
for(i=1;i<month;i++)
{
cont=cont+a[i];
}
cont=cont+date;
s=year+1+(year-1)/4+(year-1)/100+(year-1)/400+cont;
return s%7;
}
int isleap(int year)
{
if(year%4==0&&year%100||year%400==0)
return 1;
else
return 0;
}
void print(int n)
{
int i;
for(i=0;i<n;i++) printf(" ");
}
int day(int year)
{
long a,b;
if(year<=2000)
{
a=2000-year;
b=6-(a+a/4-a/100+a/400)%7;
return b;
}
else
{
a=year-2000;
b=(a+1+(a-1)/4-(a-1)/100+(a-1)/400)%7+6;
return b%7;
}
}
void printcalendar(int year)
{
int i,j,k,m,n,f1,f2,d;
int a[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
printf("\nThe calendar of the year %d.\n\n",year);
d=day(year);
if(isleap(year)==1)
a[2]++;
for(i=1;i<=12;i+=2)
{
m=0; n=0; f1=0; f2=0;
switch(i)
{
case 1:printf(" Januray 1 ");break;
case 3:printf(" March 3 ");break;
case 5:printf(" May 5 ");break;
case 7:printf(" July 7 "); break;
case 9:printf(" September 9 ");break;
case 11:printf(" Nevember 11 ");break;
}
print(21);
switch(i+1)
{
case 2:printf(" February 2 "); break;
case 4:printf(" April 4 "); break;
case 6:printf(" June 6 "); break;
case 8:printf(" August 8 "); break;
case 10:printf(" October 10 "); break;
case 12:printf(" December 12"); break;
}
printf("\n");
printf(X);
print(6);
printf(X);
printf("\n");
for(j=0;j<6;j++)
{
if(j==0)
{
print(d*4);
for(k=0;k<7-d;k++)
{
printf("%4d",++m);
}
print(6);
d+=a[i]%7;
d%=7;
print(d*4);
for(k=0;k<7-d;k++)
{
printf("%4d",++n);
}
printf("\n");
}
else
{
for(k=0;k<7;k++)
{
if(m<a[i])
{
printf("%4d",++m);
}
else
{
print(4);
}
if(m==a[i]) f1=1;
}
print(6);
for(k=0;k<7;k++)
{
if(n<a[i+1])
{
printf("%4d",++n);
}
else
{
print(4);
}
if(n==a[i+1]) f2=1;
}
printf("\n");
if(f1&&f2) break;
}
}
d+=a[i+1]%7;
d%=7;
printf(" ");
for(k=0;k<27;k++)
{
printf("=");
}
print(6);
printf(" ");
for(k=0;k<27;k++)
{
printf("=");
}
printf("\n");
if(i==5)
{
printf("Press any key to others!");
getch();
system("cls");
}
}
}
void main()
{
int choice;
int year,month,date;
int day,flag;
char con;
menu();
scanf("%d",&choice);
if(choice==1)
{
r1:system("cls");
printf("\nPlease input the year-month-date(XXXX,XX,XX):");
scanf("%d,%d,%d",&year,&month,&date);
day=getday(year,month,date);
if(day==0)
printf("\n%d-%d-%d is Sunday!\n",year,month,date);
if(day==1)
printf("\n%d-%d-%d is Monday!\n",year,month,date);
if(day==2)
printf("\n%d-%d-%d is Tuesday!\n",year,month,date);
if(day==3)
printf("\n%d-%d-%d is Wednesday!\n",year,month,date);
if(day==4)
printf("\n%d-%d-%d is Thursday!\n",year,month,date);
if(day==5)
printf("\n%d-%d-%d is Friday!\n",year,month,date);
if(day==6)
printf("\n%d-%d-%d is Saturday!\n",year,month,date);
printf("\nContinue...(Y/N)");
con=getch();
if((con=='y')||(con=='Y'))
goto r1;
if((con=='n')||(con=='N'))
main();
}
if(choice==2)
{
r2:system("cls");
printf("\nPlease input the year(XXXX):");
scanf("%d",&year);
flag=isleap(year);
if(flag==1)
printf("\nThe year %d is leap year!\n",year);
if(flag==0)
printf("\nThe year %d is not leap year!\n",year);
printf("\nContinue...(Y/N)");
con=getch();
if((con=='y')||(con=='Y'))
goto r2;
if((con=='n')||(con=='N'))
main();
}
if(choice==3)
{
r3:system("cls");
printf("\nPlease input the year(XXXX):");
scanf("%d",&year);
printcalendar(year);
printf("Continue...(Y/N)");
con=getch();
if((con=='y')||(con=='Y'))
goto r3;
if((con=='n')||(con=='N'))
main();
}
if(choice==4)
{
system("cls");
printf("\nDo you want to Exit?(Y/N)");
con=getch();
if((con=='y')||(con=='Y'))
return;
if((con=='n')||(con=='N'))
main();
}
}
H. 如何在Linux下运行C语言程序
有三个办法：
一、最直接的办法，用nohup命令，将程序挂到后台。
二、最方便的办法，用screen命令，起个虚拟终端，即使断开连接也能继续在后台跑。
三、最正常的思路，是将监听程序置为daemon，直接在后台运行，具体是监听程序启动后，fork一个子进程，将子进程setsid，然后父进程退出，实际操作都放到子进程中。
当然程序里面的循环结构是肯定要的。
I. linux下c语言编程
实在点，给你些命令操作操作，不过好象有点多，哈哈
Linux/Unix常用命令
1、目录操作
和DOS相似，UNIX采用树型目录管理结构，由根目录（/）开始一层层将子目录建下去，各子目录以 / 隔开。用户login后，工作目录的位置称为 home directory，由系统管理员设定。‘~’符号代表自己的home directory，例如 ~/myfile 是指自己home目录下myfile这个文件。
（1）显示目录文件 ls
执行格式： ls [-atFlgR] [name] (name可为文件或目录名称)
例： ls 显示出当前目录下的文件
ls -a 显示出包含隐藏文件的所有文件
ls -t 按照文件最后修改时间显示文件
ls -F 显示出当前目录下的文件及其类型
ls -l 显示目录下所有文件的许可权、拥有者、文件大小、修改时间及名称
ls -lg 同上
ls -R 显示出该目录及其子目录下的文件
注:ls与其它命令搭配使用可以生出很多技巧(最简单的如"ls -l | more")，更多用法请输入ls --help查看，其它命令的更多用法请输入 命令名 --help 查看.
（2）建新目录 mkdir
执行格式： mkdir directory-name
例： mkdir dir1 (新建一名为dir1的目录)
（3）删除目录 rmdir
执行格式： rmdir directory-name 或 rm directory-name
例：rmdir dir1 删除目录dir1，但它必须是空目录，否则无法删除
rm -r dir1 删除目录dir1及其下所有文件及子目录
rm -rf dir1 不管是否空目录，统统删除，而且不给出提示,使用时要小心
（4） 改变工作目录位置 cd
执行格式： cd [name]
例： cd 改变目录位置至用户login时的working directory
cd dir1 改变目录位置，至dir1目录
cd ~user 改变目录位置，至用户的working directory
cd .. 改变目录位置，至当前目录的上层目录
cd ../user 改变目录位置，至上一级目录下的user目录
cd /dir-name1/dir-name2 改变目录位置，至绝对路径（Full path）
cd - 回到进入当前目录前的上一个目录
（5）显示当前所在目录pwd
执行格式： pwd
（6）查看目录大小
执行格式： [-s] directory
例： dir1 显示目录dir1及其子目录容量（以kb为单位）
-s dir1 显示目录dir1的总容量
（7）显示环境变量
echo $HOME 显示家目录
echo $PATH 显示可执行文件搜索路径
env 显示所有环境变量(可能很多,最好用"env | more","env | grep PATH"等)
（8）修改环境变量，在bash下用export,如：
export PATH=$PATH:/usr/local/bin
想知道export的具体用法，可以用shell的help命令：help export
2、文件操作
（1）查看文件(可以是二进制的)内容 cat
执行格式：cat filename或more filename 或cat filename|more
例： cat file1 以连续显示方式，查看文件file1的内容
more file1
或 cat file1|more 以分页方式查看文件的内容
（2）删除文件 rm
执行格式： rm filename
例： rm file?
rm f*
（3）复制文件 cp
执行格式： cp [-r] source destination
例： cp file1 file2 将file1复制成file2
cp file1 dir1 将file1复制到目录dir1
cp /tmp/file1 将file1复制到当前目录
cp /tmp/file1 file2 将file1 复制到当前目录名为file2
cp -r dir1 dir2 (recursive )复制整个目录。
（4）移动或更改文件、目录名称mv
执行格式： mv source destination
例： mv file1 file2 将文件file1，更名为file2
mv file1 dir1 将文件file1，移到目录dir1下
mv dir1 dir2
（5）比较文件(可以是二进制的)或目录的内容 diff
执行格式： diff [-r] name1 name2 (name1、name2同为文件或目录)
例： diff file1 file2 比较file1与file2的不同处
diff -r dir1 dir2 比较dir1与dir2的不同处
（6）文件中字符串的查找 grep
执行格式： grep string file
例： grep abc file1 查找并列出串abc所在的整行文字
（7）文件或命令的路径寻找
执行格式一：whereis command 显示命令的路径
执行格式二：which command 显示路径及使用者所定义的别名
执行格式三：whatis command 显示命令的功能摘要
（8）建立文件或目录的链接 ln
例: ln source target1 建立source文件（已存在）的硬链接,命名为target1
ln -s source target2 建立source文件的符号链接,命名为target2
文件编辑器vi
vi是在UNIX 上被广泛使用的中英文编辑软件。vi是visual editor的缩写，是UNIX提供给用户的一个窗口化编辑环境。
进入vi，直接执行vi编辑程序即可。
例：$vi test.c
显示器出现vi的编辑窗口，同时vi会将文件复制一份至缓冲区（buffer）。vi先对缓冲区的文件进行编辑，保留在磁盘中的文件则不变。编辑完成后，使用者可决定是否要取代原来旧有的文件。
1、vi的工作模式
vi提供二种工作模式：输入模式（insert mode）和命令模式（command mode）。使用者进入vi后，即处在命令模式下，此刻键入的任何字符皆被视为命令，可进行删除、修改、存盘等操作。要输入信息，应转换到输入模式。
（1）命令模式
在输入模式下，按ESC可切换到命令模式。命令模式下，可选用下列指令离开vi：
：q! 离开vi，并放弃刚在缓冲区内编辑的内容
：wq 将缓冲区内的资料写入磁盘中，并离开vi
：ZZ 同wq
：x 同wq
：w 将缓冲区内的资料写入磁盘中，但并不离开vi
：q 离开vi，若文件被修改过，则要被要求确认是否放弃修改的内容，此指令可与：w配合使用
（2）命令模式下光标的移动
H 左移一个字符
J 下移一个字符
K 上移一个字符
L 右移一个字符
0 移至该行的首
$ 移至该行的末
^ 移至该行的第一个字符处
H 移至窗口的第一列
M 移至窗口中间那一列
L 移至窗口的最后一列
G 移至该文件的最后一列
W, W 下一个单词 (W 忽略标点)
B, B 上一个单词 (B 忽略标点)
+ 移至下一列的第一个字符处
- 移至上一列的第一个字符处
( 移至该句首
) 移至该句末
{ 移至该段首
} 移至该段末
NG 移至该文件的第n列
N+ 移至光标所在位置之后第n列
n- 移至光标所在位置之前第n列
（3）输入模式
输入以下命令即可进入vi输入模式：
a(append) 在光标之后加入资料
A 在该行之末加入资料
i(insert) 在光标之前加入资料
I 在该行之首加入资料
o(open) 新增一行于该行之下，供输入资料用
O 新增一行于该行之上，供输入资料用
dd 删除当前光标所在行
X 删除当前光标字符
x 删除当前光标之前字符
U 撤消
• 重做
F 查找
ESC键 离开输入模式
GNU C编译器
LINUX上可用的C编译器是GNU C编译器，它建立在自由软件基金会编程许可证的基础上，因此可以自由发布。
LINUX 上的GNU C编译器（GCC）是一个全功能的ANCI C兼容编译器。下面介绍GCC和一些GCC编译器最常用的选项。
1、使用GCC
通常后跟一些选项和文件名来使用GCC编译器。GCC命令的基本用法如下：
gcc [options] [filenames]
命令行选项指定的编译过程中的具体操作
2、GCC常用选项
GCC有超过100个的编译选项可用，这些选项中的许多可能永远都不会用到，但一些主要的选项将会频繁使用。很多的GCC选项包括一个以上的字符，因此必须为每个选项指定各自的连字符，并且就像大多数LINUX 命令一样不能在一个单独的连字符后跟一组选项。例如：
gcc test.c
编译成功后，当前目录下就产生了一个可执行文件a.out。
也可用-o选项来为即将产生的可执行文件指定一个文件名来代替a.out。例如：
gcc -o count count.c
此时得到的可执行文件就不再是a.out，而是count。
3、执行文件
格式： ./可执行文件名
例：./a.out
./count
J. 求LINUX下，C语言编写的日志输出源码~
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <dirent.h>
#include <time.h>
#define LOGFILE "./dir_log_0"
int g_Count;
//#define MAXLEN 1024
void WriteDebugLog(char *str);
int main(int argc, char **argv)
{
char str[1024]={0};
strcpy(str,"file no find");
int i=0,j=0;
for (i=0; i<10; i++)
{
for (j=0; j<50; j++)
{
WriteDebugLog(str);
}
}
return 0;
}
void WriteDebugLog(char *str)
{
char buf[2048]={0};
char logFileName[50]={0};
//long MAXLEN = 50*1024*1024;//50MB
int iMax = 1024;//1K
time_t timep;
FILE *fp = NULL;
struct tm *p;
time(&timep);
p = localtime(&timep);
memset(buf,0,sizeof(buf));
sprintf(buf,"[%d-%d-%d %d:%d:%d][DEBUG]",(1900+p->tm_year),(1+p->tm_mon), p->tm_mday,p->tm_hour, p->tm_min, p->tm_sec); //星期p->tm_wday
strcat(buf,str);
strcat(buf," ");
strcpy(logFileName,LOGFILE);
int len = strlen(logFileName);
logFileName[len-1] = Ɔ'+g_Count;
fp = fopen(logFileName,"r");
if(fp==NULL)
{
fp = fopen(logFileName,"w+");
}
else
{
fseek(fp,0,2);//SEEK_END值为2
if( ftell(fp) >= iMax)
{
fclose(fp);
if (g_Count >= 9)
{
logFileName[len-1] = Ɔ'
g_Count=0;
}
else
{
g_Count++;
logFileName[len-1] = Ɔ'+g_Count;
// printf(" %c",Ɔ'+g_Count);
}
fp = fopen(logFileName,"w+");
}
else
{
fclose(fp);
fp = fopen(logFileName,"a");
}
}
fwrite(buf,1,strlen(buf),fp);
fclose(fp);
}