Ⅰ Linux文件系统中硬链接和软链接的区别
链接和软链接的区别
1.原理上：
硬链接(hard link)：文件A是文件B的硬链接，则A的目录项中的inode节点号与B的目录项中的inode节点号相同，即一个inode节点对应两个不同的文件名，两个文件名指向同一个文件，A和B对文件系统来说是完全平等的。如果删除了其中一个，对另外一个没有影响。每增加一个文件名，inode节点上的链接数增加一，每删除一个对应的文件名，inode节点上的链接数减一，直到为0，inode节点和对应的数据块被回收。注：文件和文件名是不同的东西，rm A删除的只是A这个文件名，而A对应的数据块（文件）只有在inode节点链接数减少为0的时候才会被系统回收。
软链接(soft link)：A是B的软链接（A和B都是文件名），A的目录项中的inode节点号与B的目录项中的inode节点号不相同，A和B指向的是两个不同的inode，继而指向两块不同的数据块。但是A的数据块中存放的只是B的路径名（可以根据这个找到B的目录项）。A和B之间是“主从”关系，如果B被删除了，A仍然存在（因为两个是不同的文件），但指向的是一个无效的链接。
2.使用限制上：
硬链接：
a：不能对目录创建硬链接，原因有几种，最重要的是：文件系统不能存在链接环（目录创建时的”..”除外，这个系统可以识别出来）,存在环的后果会导致例如文件遍历等操作的混乱(，pwd等命令的运作原理就是基于文件硬链接，顺便一提，ls -l结果的第二列也是文件的硬链接数，即inode节点的链接数)
b：不能对不同的文件系统创建硬链接,即两个文件名要在相同的文件系统下。
c：不能对不存在的文件创建硬链接，由原理即可知原因。
软链接：
a.可以对目录创建软链接，遍历操作会忽略目录的软链接。
b:可以跨文件系统
c:可以对不存在的文件创建软链接，因为放的只是一个字符串，至于这个字符串是不是对于一个实际的文件，就是另外一回事了
3.命令
硬链接：ln 源文件名 链接名
软链接：ln -s 源文件名 链接名
硬链接和软链接的作用
硬链接：
硬连接的作用是允许一个文件拥有多个有效路径名，这样用户就可以建立硬连接到重要文件，以防止“误删”的功能。只删除一个连接并不影响节点本身和其它的连接，只有当最后一个连接被删除后，文件的数据块及目录的连接才会被释放。也就是说，文件真正删除的条件是与之相关的所有硬连接文件均被删除。
还有如果把链接名创建为一个以.开头的隐藏文件，还能很好的隐藏自己的隐私（你们懂的..呵呵呵）。
软链接：
软链接又称之为符号连接（Symbolic Link）。软链接文件类似于Windows的快捷方式。它实际上是一个特殊的文件。在符号连接中，文件实际上是一个文本文件，其中包含的有另一文件的位置信息。
Ⅱ c语言指令有哪些啊
第一章：绪论？
内核版本号格式：x.y.zz-www／x为主版本号，y为次版本号，zz为次次版本号，www为发行号／次版本号改变说明内核有重大变革，其偶数为稳定版本，奇数为尚在开发中的版本
第二章：基础？
文件种类：-：txt，二进制／d：目录／l：链接文件（link）／b：区块设备文件／c：字符设备文件／p：管道
目录结构：bin：可执行／boot：开机引导／dev：设备文件／etc：系统配置文件／lib：库文件／mnt：设备挂载点／var：系统日志／
命令：rmdir：删除空目录／find [path] [expression]／touch命令还可以修改指定文件的最近一次访问时间／tar -czvf usr.tar.gz path／tar –zxvf usr.tar.gz／tar –cjvf usr.tar.bz2 path／tar –jxvf usr.tar.bz2
gcc：预处理：-g／I在头文件搜索路径中添加目录，L在库文件搜索路径中
gdb：设置断点：b／查看断点信息：info
Makefile：make –f other_makefile／<：第一个依赖文件的名称／@：目标文件的完整名称／^：所有不重复的依赖文件／+：所有依赖文件（可能重复）
第三章：文件IO
read：read(fd, temp, size); ／读fd中长度为size的值到temp／返回0表示file为NULL
write：write(fd, buf, buf_size); ／写长度为buf_size的buf内容到fd中
lseek：lseek(fd, offset, SEEK_SET); ／从文件开头向后增加offset个位移量
unlink：从文件系统中删除一个名字
open1：int open(const char * pathname, int flags, mode_t mode);／flags为读写方式／mode为权限设置／O_EXCL：测试文件是否存在／O_TRUNC：若存在同名文件则删除之并新建
open2：注意O_NONBLOCK
mmap.1：void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offsize);
mmap.2：mmap(start_addr, flength, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
fcntl：上锁／int fcntl(int fd, int cmd, struct flock * lock);／对谁；做什么；设置所做内容
select：fd_max+1，回传读状况，回传写状况，回传异常，select等待的时间／NULL为永远等待／0为从不等待／凡需某状况则用之，反则(fd_set *)NULL之
FD_*那几个函数……
一般出错则返回-1
第四章：文件与目录
硬链接与符号链接？
chdir改变目录
0：in／1：out／2：err
第五章：内存管理
可执行文件存储时：代码区、数据区和未初始化区
栈：by编译器，向低址扩展，连续，效率高／堆：by程序员
/etc/syslog.conf，系统log记录文件／优先级为-20时最高
第六章：进程和信号
程序代码、数据、变量、文件描述符和环境／init的pid为1
execl族：int execl(const char * path, const char * arg, ....);／path即可执行文件的路径，一般为.／最后一个参数以NULL结束
waitpid：waitpid(pid_t pid,int * status,int options);／option：一般用WNOHANG，没有已经结束的子进程则马上返回，不等待
kill：int kill(pid_t pid,int sig);／发送信号sig给pid
void (*signal(int signum, void(* handler)(int)))(int);／第一个参数被满足时，执行handler／第一个参数常用：SIG_IGN：忽略信号／SIG_DFL：恢复默认信号
第七章：线程
sem_init(sem_t *sem, int pshared, unsigned int value)／pshared为0／value即初始值
第八章：管道
1：write／0：read
第九章：信号量、共享内存和消息队列
临界资源：操作系统中只允许一个进程访问的资源／临界区：访问临界资源的那段代码
信号量：建立联系（semget），然后初始化，PV操作，最后destroy
共享内存没有提供同步机制
第十章：套接字
UDP：无连接协议，无主客端的区分／实时性
TCP：字节流／数据可靠性／网络可靠性
数据报：SOCK_STREAM／SOCK_DGRAM
其它
管道一章的both_pipe即父子进程间的全双工管道通讯
关系到信号和互斥的服务器-客户端程序
线程一章的class的multi_thread文件夹下的thread8.c
int main(void)
{
int data_processed;
int file_pipes_1[2];
int file_pipes_2[2];
char buffer[BUFSIZ + 1];
const char some_data[] = "123";
const char ch2p[] = "this is the string from child to the parent!";
const char p2ch[] = "this is the string from parent to the child!";
pid_t fork_result;
memset(buffer,'\0',sizeof(buffer));
if(pipe(file_pipes_1) == 0){
if(pipe(file_pipes_2) == 0){
fork_result = fork();
switch(fork_result){
case -1:
perror("fork error");
exit(EXIT_FAILURE);
case 0://child
close(file_pipes_1[1]);
close(file_pipes_2[0]);
printf("in the child!\n");
read(file_pipes_1[0],buffer, BUFSIZ);
printf("in the child, read_result is \"%s\"\n",buffer);
write(file_pipes_2[1],ch2p, sizeof(ch2p));
printf("in the child, write_result is \"%s\"\n",ch2p);
exit(EXIT_SUCCESS);
default://parent
close(file_pipes_1[0]);
close(file_pipes_2[1]);
printf("in the parent!\n");
write(file_pipes_1[1], p2ch, sizeof(p2ch));
printf("in the parent, write_result is \"%s\"\n",p2ch);
read(file_pipes_2[0],buffer, BUFSIZ);
printf("in the parent, read_result is \"%s\"\n",buffer);
exit(EXIT_SUCCESS);
}
}
}
}
#ifndef DBG
#define DBG
#endif
#undef DBG
#ifdef DBG
#define PRINTF(fmt, args...) printf("file->%s line->%d: " \
fmt, __FILE__, __LINE__, ##args)
#else
#define PRINTF(fmt, args...) do{}while(0);
#endif
int main(void)
{
PRINTF("%s\n", "hello!");
fprintf(stdout, "hello hust!\n");
return 0;
}
#define N 5
#define MAX 5
int nput = 0;
char buf[MAX][50];
char *buffer = "";
char buf_r[100];
sem_t mutex,full,avail;
void *proctor(void *arg);
void *consumer(void *arg);
int i = 0;
int main(int argc, char **argv)
{
int cnt = -1;
int ret;
int nput = 0;
pthread_t id_proce[10];
pthread_t id_consume;
ret = sem_init(&mutex, 0, 1);
ret = sem_init(&avail, 0, N);
ret = sem_init(&full, 0, 0);
for(cnt = 0; cnt < 6; cnt ++ ){
//pthread_create(&id_proce[cnt], NULL, (void *)proctor, &cnt);
pthread_create(&id_proce[cnt], NULL, (void *)proctor, (void *)cnt);
}
pthread_create(&id_consume, NULL, (void *)consumer, NULL);
for(cnt = 0; cnt < 6; cnt ++){
pthread_join(id_proce[cnt], NULL);
}
pthread_join(id_consume,NULL);
sem_destroy(&mutex);
sem_destroy(&avail);
sem_destroy(&full);
exit(EXIT_SUCCESS);
}
void *proctor(void *arg)
{
while(1){
sem_wait(&avail);
sem_wait(&mutex);
if(nput >= MAX * 3){
sem_post(&avail);
//sem_post(&full);
sem_post(&mutex);
return NULL;
}
sscanf(buffer + nput, "%s", buf[nput % MAX]);
//printf("write[%d] \"%s\" to the buffer[%d]\n", (*(int*)arg), buf[nput % MAX],nput % MAX);
printf("write[%d] \"%s\" to the buffer[%d]\n", (int)arg, buf[nput % MAX],nput % MAX);
nput ++;
printf("nput = %d\n", nput);
sem_post(&mutex);
sem_post(&full);
}
return NULL;
}
void *consumer(void *arg)
{
int nolock = 0;
int ret, nread, i;
for(i = 0; i < MAX * 3; i++)
{
sem_wait(&full);
sem_wait(&mutex);
memset(buf_r, 0, sizeof(buf_r));
strncpy(buf_r, buf[i % MAX], sizeof(buf[i % MAX]));
printf("read \"%s\" from the buffer[%d]\n\n",buf_r, i % MAX);
sem_post(&mutex);
sem_post(&avail);
//sleep(1);
}
return NULL;
}
Ⅲ C++问题(指针&引用)
指针存放的是地址，可以指向任一内存地址，然后修改地址指向的内存里的内容，所以如果操作不当，指向一个未知的内存，容易导致系统崩溃。故有了引用的概念，变量的引用可以理解为别名，也是为了用户可以直接操作变量原本的内存地址的内容，类似Linux中的硬链接。但是这样的思想让用户声明的引用实际操作的地址一定是实际存在的地址，不会发生错误。
而C++的引用完全是为了兼容C，C语言一般用在嵌入式行业，需要指向任一地址才可以操作不同地址的外设，面向过程也能封装成面向对象的思想来编程，所以嵌入式开发基本上都是用C语言而不是C++。你会发现Java、Python、PHP等语言都已经抛弃了指针的概念，都只有引用。所以C++里没必要再用指针了，会引用就行。
至于你的第二个问题，那是引用的基本定义，如果直接int r=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
Ⅳ 关于c语言中变量有外部链接内部链接和无 链接怎么理解
这部分内容是在程序的编译和link层面谈的。
一个大一些的工程往往不是只有一个程序文件，经常由好多C程序文件构成，有的时候里面个别程序可能还用的其他语言，编码完成后常常分别编译，编译完成再link到一起。某个C程序需要用到其他程序中定义过的变量，一般都加extern前缀，编译时编译器会预留访问链接的空位，等到link阶段再在整个工程的其他C编译结果中去对号，把访问链接填上。这就是外部链接。如果你程序全写在一个文件里，那永远都不会有外部链接。
内部链接常指一个程序文件中全局变量，可以被程序文件内各个子程序访问，这在编译过程中处理，和link阶段不发生关系。如果变量前加了static，那么它永远不会被外部程序访问，它不会被编译程序写入目标代码的链接区。
无链接，就是在一个单体程序里，比如一个子程序，定义一个变量只给这个程序段用，那就是无链接。编译器和link都不需要对这样的变量做跨程序段的地址链接，这样的变量都是直接分配寄存器或者近堆中的直接地址（每个子程序都有自己的基本存储空间，被调用时得到分配，返回时被释放，我习惯叫它近堆，标准叫啥早不记得了）。
变量是这样，程序代码段也大体差不多。每次在程序文件中调用一个文件内部的子程序，就产生一个内部链接；如果调用外部文件中的子程序，就产生一个外部链接。只有没有任何子程序，所有代码都写在一个文件里的程序，才是无链接程序。
链接是个编译和link层面的概念，所以不仅限于变量层面讨论。
对了，再延伸，可以把一些子程序文件归类，程序执行某部分任务才访问，其他时间不访问时，可以生成DLL。在程序执行那部分功能时，通过操作系统和DLL建立动态链接，当然这是外部链接，这也是程序设计中常用到的。这可以避免生成一个巨大的EXE，运行时吃掉过多的系统资源，还可以实现这个DLL中包含的子程序在操作系统级和其他程序共用。
Ⅵ 计算机二级C语言一道选择题，求详细解法！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
/*
* 此程序可以ls 多个文件
* 范例： ./myls file1 file2 dt1 dt2 后面参数可以多个，
*
*/
#include <pwd.h>
#include <grp.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <limits.h>
#include <time.h>
#include <stdio.h>
/*
* 读取不是目录的文件
* argv : 文件名
* 返回值： 出错1， 正确0
*/
int lsregfile(char *argv) //读取不是目录的文件
{
struct stat buf;
if (lstat(argv, &buf) < 0) //读取文件信息。
{
printf("%s:stat error\n",argv);
return 1;
}
char str[10] = "";
/******************判断文件的类型***********************/
if (S_ISREG(buf.st_mode)) str[0] = '-';
else if (S_ISDIR(buf.st_mode)) str[0] = 'd';
else if (S_ISCHR(buf.st_mode)) str[0] = 'c';
else if (S_ISBLK(buf.st_mode)) str[0] = 'b';
else if (S_ISFIFO(buf.st_mode)) str[0] = 'p';
#ifdef S_ISLNK
else if (S_ISLNK(buf.st_mode)) str[0] = 'l';
#endif
#ifdef S_ISSOCK
else if (S_ISSOCK(buf.st_mode)) str[0] = 's';
#endif
else str[0] = 'U'; //表示未知文件类型
/************************* 输出权限 ************************/
str[1] = ((buf.st_mode & S_IRUSR) != 0) ? 'r' : '-';
str[2] = ((buf.st_mode & S_IWUSR) != 0) ? 'w' : '-';
str[3] = ((buf.st_mode & S_IXUSR) != 0) ? 'x' : '-';
//判断设置-用户-ID
str[3] = ((buf.st_mode & S_ISUID) != 0) ? 's' : str[3];
str[4] = ((buf.st_mode & S_IRGRP) != 0) ? 'r' : '-';
str[5] = ((buf.st_mode & S_IWGRP) != 0) ? 'w' : '-';
str[6] = ((buf.st_mode & S_IXGRP) != 0) ? 'x' : '-';
//判断设置-用户组-ID
str[6] = ((buf.st_mode & S_ISGID) != 0) ? 'x' : str[6];
str[7] = ((buf.st_mode & S_IROTH) != 0) ? 'r' : '-';
str[8] = ((buf.st_mode & S_IWOTH) != 0) ? 'w' : '-';
str[9] = ((buf.st_mode & S_IXOTH) != 0) ? 'x' : '-';
printf("%s ", str);
// 输出硬链接数
printf("%3ld ", (long) buf.st_nlink);
// 输出文件所有者。
struct passwd *ppd;
ppd = getpwuid(buf.st_uid);
printf("%-5s ", ppd->pw_name);
// 输出文件所有者的组名
struct group *pgroup;
pgroup = getgrgid(buf.st_gid);
printf("%-5s ", pgroup->gr_name);
// 输出文件大小
printf("%5lld ", (long long) buf.st_size);
// 输出最近修改时间
struct tm *ptime = NULL;
ptime = gmtime(&buf.st_mtime);
printf("%.4d-%.2d-%.2d %.2d:%.2d ",
(1900 + ptime->tm_year),
(1 + ptime->tm_mon),
ptime->tm_mday,
ptime->tm_hour,
ptime->tm_min);
// 输出文件名
printf("%s", argv);
if (str[0] == 'l') //如果是链接文件，获取链接对象名
{
printf(" -> ");
char linkbuf[100] = "";
if (readlink(argv, linkbuf, sizeof(buf)) < 0 )
{
printf("%s: readlink error\n",argv);
return 1;
}
printf("%s", linkbuf);
}
printf("\n");
return 0;
}
/*
* 读取目录里面不带.和..的所有文件的信息.
* argv : 文件名
* 返回值： 出错1， 正确0
*/
int lsdir(char *argv) //读取目录
{
printf("%s:\n", argv);
DIR *pread;
pread = opendir(argv);// 打开目录
if (pread == NULL)
{
printf("%s: opendir error\n",argv);
return 1;
}
if (chdir(argv) < 0) //修改工作目录 使下面的stat能成功.
{
printf("%s chdir error\n", argv);
return 1;
}
struct dirent *pd = NULL;
long long ssize = 0;
while ((pd = readdir(pread)) != NULL)
{
if ((!strcmp(pd->d_name, ".")) || (!strcmp(pd->d_name, "..")))
continue; //当文件为.或..时跳过。
struct stat buf;
if (lstat(pd->d_name, &buf) < 0) //读取文件信息。
{
printf("%s: stat error\n", argv);
return 1;
}
char str[10] = "";
/******************判断文件的类型***********************/
if (S_ISREG(buf.st_mode)) str[0] = '-';
else if (S_ISDIR(buf.st_mode)) str[0] = 'd';
else if (S_ISCHR(buf.st_mode)) str[0] = 'c';
else if (S_ISBLK(buf.st_mode)) str[0] = 'b';
else if (S_ISFIFO(buf.st_mode)) str[0] = 'p';
#ifdef S_ISLNK
else if (S_ISLNK(buf.st_mode)) str[0] = 'l';
#endif
#ifdef S_ISSOCK
else if (S_ISSOCK(buf.st_mode)) str[0] = 's';
#endif
else str[0] = 'U'; //表示未知文件类型
/************************* 输出权限 ************************/
str[1] = ((buf.st_mode & S_IRUSR) != 0) ? 'r' : '-';
str[2] = ((buf.st_mode & S_IWUSR) != 0) ? 'w' : '-';
str[3] = ((buf.st_mode & S_IXUSR) != 0) ? 'x' : '-';
//判断设置-用户-ID
str[3] = ((buf.st_mode & S_ISUID) != 0) ? 's' : str[3];
str[4] = ((buf.st_mode & S_IRGRP) != 0) ? 'r' : '-';
str[5] = ((buf.st_mode & S_IWGRP) != 0) ? 'w' : '-';
str[6] = ((buf.st_mode & S_IXGRP) != 0) ? 'x' : '-';
//判断设置-用户组-ID
str[6] = ((buf.st_mode & S_ISGID) != 0) ? 'x' : str[6];
str[7] = ((buf.st_mode & S_IROTH) != 0) ? 'r' : '-';
str[8] = ((buf.st_mode & S_IWOTH) != 0) ? 'w' : '-';
str[9] = ((buf.st_mode & S_IXOTH) != 0) ? 'x' : '-';
printf("%s ", str);
// 输出硬链接数
printf("%3ld ", (long) buf.st_nlink);
// 输出文件所有者。
struct passwd *ppd;
ppd = getpwuid(buf.st_uid);
printf("%-5s ", ppd->pw_name);
// 输出文件所有者的组名
struct group *pgroup;
pgroup = getgrgid(buf.st_gid);
printf("%-5s ", pgroup->gr_name);
// 输出文件大小
printf("%5lld ", (long long) buf.st_size);
ssize += buf.st_size;
// 输出最近修改时间
struct tm *ptime = NULL;
ptime = gmtime(&buf.st_ctime);
printf("%.4d-%.2d-%.2d %.2d:%.2d ",
(1900 + ptime->tm_year),
(1 + ptime->tm_mon),
ptime->tm_mday,
ptime->tm_hour,
ptime->tm_min);
// 输出文件名
printf("%s", pd->d_name);
if (str[0] == 'l') //如果是链接文件，获取链接对象名
{
printf(" -> ");
char linkbuf[100] = "";
if (readlink(pd->d_name, linkbuf, sizeof(buf)) < 0 )
{
printf("%s: readlink error\n", argv);
return 1;
}
printf("%s", linkbuf);
}
printf("\n");
}
// 输出总用量
printf("总用量 %lld\n", ssize/1024);
///////////////////////////////////////////////////////
if (closedir(pread) < 0) //关闭目录
{
printf("%s: closedir error\n", argv);
return 1;
}
}
/*
*
* 这个程序，把非目录文件和目录分开读。
*
*/
int main(int argc, char *argv[])
{
if (argc == 1)
{
printf("the argument is wrong\n");
exit(1);
}
int i;
for (i = 1; i < argc; ++i)
{
// 保存当前的工作目录。以便返回当前工作目录
char bufpwd[80];
char *getp =NULL;
getp = getcwd(bufpwd, sizeof(bufpwd));
if (getp == NULL)
{
printf("%s : getcwd error\n",argv[i]);
return 1;
}
struct stat buf0; //获取文件信息
if (stat(argv[i], &buf0) < 0)
{
printf("%s: stat error\n", argv[i]);
continue; //出错跳过
}
if (!S_ISDIR(buf0.st_mode)) //如果读取的不是目录。就直接去读文件。
lsregfile(argv[i]); //读文件
else
lsdir(argv[i]); //读目录
// 改变工作目录回原来的工作目录，以便读取相对路径的文件
if (chdir(bufpwd) < 0)
{
printf("%s : chdir error\n", argv[i]);
return 1;
}
}
return 0;
}
Ⅶ Unix系统中的link和ln命令有什么区别
可以从man中找到答案。man link 然后 man ln。
前面是方法，这里是结论，
man中清楚看到，link功能简单，只能制作硬链接，而ln有很多参数可以选。