更具体地说，这意味着 Linux 使用相同的一组系统调用来提供对设备（例如软盘和磁带设备）、网络资源（最常见的是 TCP/IP 连接）、系统终端，甚至内核状态信息的访问。感谢无所不在的系统调用，娴熟地使用与文件相关的调用对于每个 Linux 程序员来说都很重要。让我们仔细查看一下文件 API 背后的一些基本概念，并描述最重要的文件相关系统调用。

Linux 提供许多不同种类的文件。最常见的类型就简称为常规文件，它存储大量用于以后访问的信息。您所使用的绝大部分文件 -- 例如可执行文件（如 /bin/vi）、数据文件（如 /etc/passwd）和系统二进制文件（如 /lib/libc.so.6）-- 都是常规文件。它们通常驻留在磁盘上的某处，但我们稍后会发现，并不一定都是这种情况。

另一种文件类型是目录，它包含了一个其它文件及其位置的列表。使用 ls 命令列出目录中的文件时，它打开该目录的文件，并打印出它所包含的所有文件的信息。

其它文件类型包括块设备（表示文件系统高速缓存的设备，例如硬盘驱动器）、字符设备（表示非高速缓存的设备，例如磁带驱动器、鼠标和系统终端）、管道和套接字（允许进程相互之间对话），以及符号链接（允许文件在目录层次结构中有多个名称）。

大多数文件都有一个或多个引用它们的符号名。这些符号名是一组由 / 字符定界的字符串，并向内核标识文件。它们是 Linux 用户所熟悉的路径名；例如，路径名 /home/ewt/article 引用的是我手提电脑中包含这篇文章文本的文件。没有两个文件可以共享相同的名称（但单一文件可以有多个名称），因此路径名唯一地标识单一文件。

进程可以访问的每个文件都由一个小的非负整数标识，称为“文件描述符”。文件描述符由打开文件的系统调用创建，并由从当前进程创建的新子进程继承。就是说，当进程启动了一个新程序时，原始进程的打开文件通常是由新程序继承的。

按照约定，大多数程序保留前三个文件描述符（0、1 和 2）用于特殊目的 -- 访问所谓的标准输出、标准输出和标准错误流。文件描述符 0 是标准输入，这里许多程序都将从外部世界接收输入。文件描述符 1 是标准输出。大多数程序在这里显示正常的输出。对于与错误情况相关的输出，使用文件描述符 2（标准错误）。

任何习惯使用 Linux shell 的人都曾看到过标准输入、输出和错误文件描述符的使用。通常，shell 运行命令时带文件描述符 0、1 和 2，都是指 shell 的终端。当使用 > 字符指示 shell 将一个程序的输出发送给另一个程序时，shell 在调用新程序之前打开该文件作为文件描述符 1。这将导致程序将它的输出发送给指定的文件而不是用户终端；其妙处是，对于程序本身，这是透明的！

与之类似，"<" 字符指示 shell 使用特定的文件作为文件描述符 0。这样就强迫程序从该文件中读取它的输入；这两种情况下，任何来自程序的错误仍将出现在终端上，如同它们在文件描述符 2 的情况下发送给标准错误一样。（在 "bash" shell 中，可以使用 2> 而不是 > 将标准错误重定向）。这种类型的文件重定向是 Linux 命令行最强大的特性之一。

使用任何与文件相关的系统调用之前，程序应该包括 <fcntl.h> 和 <unistd.h>；它们为最普遍的文件例程提供了函数原型和常数。在下面的示例代码中，我们假设每个程序开始处都有

#include <fcntl.h>
#include <unistd.h>

首先，让我们了解如何读写文件。凭直觉就可以知道，read() 和 write() 系统调用是执行这些操作的最常用方法。这两种系统调用将有三个自变量：要访问的文件描述符、指向要读写的信息的指针以及应该读写的字符数。返回成功读写的 字符数。清单 1 说明了一个简单的程序，它从标准输入（文件描述符 0）中读取一行，并将它写入标准输出（文件描述符 1）：

清单 1：

void main(void) {
char buf[100];
int num;

num = read(0, buf, sizeof(buf));
write(1, "I got: ", 7); /* Length of "I got: " is 7! */
write(1, buf, num);
}

关于这个处理有两个值得注意的问题。首先，我们要求 read() 返回 100 个字符，但如果我们运行这个程序，只有在用户按下了 "enter" 键以后才能获得输入。许多文件操作都根据最佳效果工作：它们尝试返回程序要求的所有信息，但只有部分能够成功。缺省情况下，终端配置成一旦存在 "\n" 或新行符（通过按 "enter" 键产生）时，就从 read() 调用返回。这实际上非常方便，因为大多数用户都希望程序无论如何都是面向行的。但常规数据文件并非如此，如果依靠它就可能产生不可预料的结果。

另一个要注意的问题是我们不必在显示输出后写一个 \n。read() 调用给了我们来自用户的 \n，只将那个 \n 通过 write() 写回标准输出。如果您希望在没有新行符的情况下看到发生的事件，尝试将最后一行改为

write(1, buf, num - 1);

有关这个简单示例的最后一点：buf 绝对不包含实际的 C 字符串。C 字符串由标记字符串结束的单一 \0 字符终止。因为 read() 不将 \0 添加到缓冲区的结尾，在 read() 上使用 strlen()（或任何其它 C 字符串函数）将可能铸成大错！这种行为可以让 read() 和 write() 对包括 \0 字符的数据处理，而这对于一般字符串函数来说是不可能的。

read() 和 write() 系统调用可以对绝大多数文件起作用。但它们不对目录起作用，目录应该通过特殊函数（例如 readdir()）来访问。另外，read() 和 write() 对于某些类型的套接字也不起作用。

某些文件，例如常规文件和块设备文件，使用文件指针的概念。它指定在文件中，下一个 read() 调用从哪里读取，下一个 write() 调用从哪里写入。read() 或 write() 后，文件指针随着已处理的字符数（在内部，通过内核）增加。这样，使用单一循环就可以方便地读取文件中的所有数据。清单 2 就是示例：

清单 2：

char buffer[1024];
while ((num = read(0, buffer, 1024))) {
printf("got some data\n");
}

这个循环将读取标准输入上的所有数据，自动在每次读取后增加内核的内部文件指针。当文件指针处于文件结尾时，read() 将返回 0 并退出循环。某些文件（例如字符设备 -- 终端就是很好的一例）本身没有文件指针，所以对于这一点，该程序将继续运行，直到用户提供文件结束标记（通过按 "Ctrl-D"）为止。

到现在为止，我们已经知道如何读写文件了，下一步要学习如何打开一个新文件。打开不同类型的文件有不同方法；我们将在这里讨论的方法是通过路径名打开在文 件系统中表示的文件；包括常规文件、目录、设备文件和指定的管道。某些套接字文件有路径名，那些必须通过替代方法打开。

撇开放弃权利的，open() 系统调用可以让程序访问大多数系统文件。open() 是个不寻常的系统调用，因为它获取两个或者三个自变量：

int open(const char *
pathname,
int flags);

或者，
int open(const char *
pathname,
int flags,
int perm);

第一种形式更普遍一些；它打开一个已存在的文件。第二种格式应该在需要创建文件时使用。第三个自变量指定应该给予新文件的访问权限。

open() 的第一个参数是以正常 C 字符串表示的全路径名（即以 \0 终止）。第二个参数指定文件应该如何打开，并包括逻辑“与”操作的一个或多个以下标志：

O_RDONLY：文件可以只读
O_RDWR：文件可以读写
O_APPEND：文件可以读或附加
O_CREAT：如果文件还不存在则应该创建
O_EXCL：如果文件已存在，失败而不是创建它（只应该使用 O_CREAT）
O_TRUNC：如果文件已存在，从中除去所有数据（与创建新文件类似）

open() 的第三个参数只在使用 O_CREAT 时需要；它指定了以数字表示的文件许可权（格式与 chown 命令的数值许可权自变量的格式相同。为 open() 指定的许可权受用户的 umask 影响，后者允许用户指定一系列新文件应该获得的缺省许可权。大多数创建文件的程序都使用第三个自变量 0666 调用 open()，可以让用户通过 umask 来控制程序的缺省许可权。（大多数 shell 的 umask 命令都可以更改它。）

例如，清单 3 显示了如何为进行读写打开文件、如果它不存在则创建，以及废弃其中的数据：

清单 3：

int fd;
fd = open("myfile", O_RDWR | O_CREAT | O_TRUNC, 0666)
if (fd < 0) {
/* Some error occurred */
/* ... */
}

open() 返回引用文件的文件描述符。回忆一下，文件描述符总是 >= 0。如果 open() 返回了一个负值，就表示发生了错误，全局变量错误号包含了描述问题的 Unix 错误代码。open() 总尽量返回最小数，如果没有使用文件描述符 0，open() 将总返回 0。

进程带文件结束时，它应该通过 close() 系统调用关闭它，该系统调用的格式为：

int close(int fd);

close 的文件描述符是传递给 close() 的唯一自变量，在成功情况下返回 0。尽管 close() 失败的情况比较少见，但如果文件描述符引用的是远程服务器上的文件，系统无法正确清空它的高速缓存，close() 就可能真的失败。进程终止时，内核自动关闭所有还在打开的文件。

最后的一个常见文件操作是移动文件指针。这（自然）只对带文件指针的文件有意义，如果尝试在不恰当的文件上尝试该操作就会返回错误。lseek() 系统调用用于以下目的：

off_t lseek(int fd, off_t pos, int whence);

off_t 类型是表达 longint （long 就是 lseek 中 "l" 的来历）的一种别致方法。lseek() 返回相对于文件开始处文件指针的最终位置，如果有错误，则返回 -1。这个系统调用希望被移动的文件指针所属的文件描述符作为第一个自变量，将它移动到文件中的位置作为第二个自变量。最后一个自变量描述文件指针的移动 方式。

SEEK_SET 将它移动到从文件开始算起的 pos 字节。
SEEK_END 将它移动到从文件结尾算起的 pos 字节。
SEEK_CUR 从它当前位置开始向文件结尾移动 pos 字节。

open()、close()、write()、read() 和 lseek() 的组合为 Linux 提供了基本的文件访问 API。虽然还有许多其它操纵文件的函数，但这里描述的是最常用的。

大多数程序员都使用熟悉的 ANSI C 库文件函数，例如 fopen() 和 fread()，而不是在此描述的低级系统调用。可以预见到，fopen() 和 fread() 是在用户级别库中这些系统调用的基础上实现的。仍然会经常看到低级系统调用的使用，特别是在更复杂的程序中。通过熟悉这些例程和接口，您就可以成为一个真 正的 Unix 黑客了。

关于作者
Erik Troan 是 Red Hat Software 的开发者，Linux Application Development 一书的作者之一。可以通过 ewt@redhat.com 与他联系。

1      tr -d  ''\r''<oldfile> newfile    **删掉回车**

2 应用-s参数：-s 删除所有重复出现字符序列，只保留第一个；

              即将重复出现字符串压缩为一个字符串。例如：

  tr  -s "\n"<oldfile> newfile    **删掉空行**

3      tr  "[a-z]" "[A-Z]"<oldfile> newfile   **小写到大写**

    或 tr  "[:lower:]" "[:upper:]"<oldfile> newfile

有问题的两点：

1 $ echo "this is a test " | tr -s "this" "that"

    that at a tet #不能够根据整个词进行替换

2 $ echo "this is a test " | tr -d "is"

    th  a tet  #把每一个字符都删除，不能当做整个字符串来处理

　　指令：mkfs

　　使用权限: 超级使用者

　　使用方式: mkfs [-V] [-t fstype] [fs-options] filesys [blocks]

　　说明：建立 linux 档案系统在特定的 partition 上

　　参数：

　　例子:

　　在 /dev/hda5 上建一个 msdos 的档案系统，同时检查是否有坏轨存在，并且将过程详细列出来:

　　mkfs -V -t msdos -c /dev/hda5

Linux 指令：文件系统--sync

　　名称 : sync

　　使用权限 : 系统管理者

　　使用方式 : sync

　　说明 : Linux 系统中欲写入硬盘的资料有的时候会了效率起见，会写到 filesystem buffer 中，这个 buffer 是一块记忆体空间，如果欲写入硬盘的资料存于此 buffer 中，而系统又突然断电的话，那么资料就会流失了，sync 指令会将存于 buffer 中的资料强制写入硬盘中。

名称: swapon

　　使用者权限: 超级使用者(super-user)

　　使用方式:

　　参数：

　　swapon 是开启swap。

　　相对的，便有一个关闭swap的指令，swapoff。

1．4 icache中的inode对象存取接口——iget／iput

1．4．1 iget()——引用一个inode对象
其他内核模块要想访问一个inode对象，必须通过iget()访问接口。该函数会首先在icache的哈希链表中查找相应的inode对象，如果找到，则将该对象的引用计数加1，然后返回该inode对象的指针。如果没有找到，则通过调用get_new_inode（）函数分配一个新的inode对象。该函数的源代码如下所示（include/linux/fs.h）：
static inline struct inode *iget(struct super_block *sb, unsigned long ino)
{
return iget4(sb, ino, NULL, NULL);
}
可以看出，实际的工作是由iget4()函数（带有4个参数的iget函数，所以叫iget4）来完成的，其源码如下（inode.c）：
struct inode *iget4(struct super_block *sb, unsigned long ino, find_inode_t find_actor, void *opaque)
{
struct list_head * head = inode_hashtable + hash(sb,ino);
struct inode * inode;

spin_lock(&inode_lock);
inode = find_inode(sb, ino, head, find_actor, opaque);
if (inode) {
__iget(inode);
spin_unlock(&inode_lock);
wait_on_inode(inode);
return inode;
}
spin_unlock(&inode_lock);

/*
* get_new_inode() will do the right thing, re-trying the search
* in case it had to block at any point.
*/
return get_new_inode(sb, ino, head, find_actor, opaque);
}
NOTE:
（1）首先，通过散列函数hash找到该inode对象应该在那个哈希链表中，然后调用find_inode（）函数在该哈希链表中查找是否存在该inode对象。。
（2）如果在哈希链表中找到了相应的inode对象（由超级块对象指针sb和索引节点号ino唯一确定），则先调用__iget（）函数增加该inode对象的引用计数。然后调用wait_on_inode（）函数等待该inode对象被其他内核模块解锁。最后，直接返回这个inode对象的指针。
（3）如果没有找到，则调用get_new_inode()函数分配一个新的inode对象。
内联函数__iget()用来增加一个inode对象的引用计数。该函数首先判断inode对象的I_count的当前值。如果它非0，则将I_count加1后就直接返回。如果它为0，则先将I_count加1，然后就看看这个inode对象当前是否为脏，如果为脏（I_state&I_DIRTY非0），那就什么也不做，让该inode对象继续待在超级块对象的s_dirty链表中。如果不为脏，则将该inode对象从原来的“类型”链表（应该在inode_unused链表中）中删除，并将其连入到inode_in_use链表中。最后将icache统计信息中的未使用inode个数减1。
static inline void __iget(struct inode * inode)
{
if (atomic_read(&inode->i_count)) {
atomic_inc(&inode->i_count);
return;
}
atomic_inc(&inode->i_count);
if (!(inode->i_state & I_DIRTY)) {
list_del(&inode->i_list);
list_add(&inode->i_list, &inode_in_use);
}
inodes_stat.nr_unused--;
}
wait_on_inode()函数测试一个inode对象是否已经被加锁，如果是，则调用__wait_on_inode()函数等待该inode被解锁。否则就直接返回：
static inline void wait_on_inode(struct inode *inode)
{
if (inode->i_state & I_LOCK)
__wait_on_inode(inode);
}
get_new_inode()函数用于得到一个新的inode对象。该函数首先调用alloc_inode宏从inode_cachep这个slab分配器缓存中分配一个新的inode对象。如下所示：
static struct inode * get_new_inode(struct super_block *sb, unsigned long ino, struct list_head *head, find_inode_t find_actor, void *opaque)
{
struct inode * inode;

inode = alloc_inode();
if (inode) {
struct inode * old;

spin_lock(&inode_lock);
/* We released the lock, so.. */
old = find_inode(sb, ino, head, find_actor, opaque);
if (!old) {
inodes_stat.nr_inodes++;
list_add(&inode->i_list, &inode_in_use);
list_add(&inode->i_hash, head);
inode->i_sb = sb;
inode->i_dev = sb->s_dev;
inode->i_ino = ino;
inode->i_flags = 0;
atomic_set(&inode->i_count, 1);
inode->i_state = I_LOCK;
spin_unlock(&inode_lock);

clean_inode(inode);
sb->s_op->read_inode(inode);

/*
* This is special! We do not need the spinlock
* when clearing I_LOCK, because we're guaranteed
* that nobody else tries to do anything about the
* state of the inode when it is locked, as we
* just created it (so there can be no old holders
* that haven't tested I_LOCK).
*/
inode->i_state &= ~I_LOCK;
wake_up(&inode->i_wait);

return inode;
}

/*
* Uhhuh, somebody else created the same inode under
* us. Use the old inode instead of the one we just
* allocated.
*/
__iget(old);
spin_unlock(&inode_lock);
destroy_inode(inode);
inode = old;
wait_on_inode(inode);
}
return inode;
}

（1）由于在调用get_new_inode函数时，调用者已经释放了inode_lock锁，因此在inode_lock被释放到调用get_new_inode函数期间，其他内核模块有可能已经创建了（sb,ino）所确定的索引节点。所以，get_new_inode函数必须重新调用find_inode函数，以再一次在哈希链表中查找是否已存在相应的inode对象。
（2）如果find_inode（）返回一个有效的指针，则说明其它模块已经创建了（sb,ino）这个inode对象，因此就要调用destroy_inode（）函数来销毁一开始创建的inode对象，然后调用__iget()函数增加所找到的inode对象的引用计数，然后用wait_on_inode（）函数等待他被解锁。
（3）如果find_inode()返回NULL，则对先前所分配的inode对象进行初始化。其中，要调用clean_inode（）函数和超级块的s_op->read_inode()方法，以从块设备上读取磁盘索引节点的内容。最后，返回所分配的inode对象的指针。

1．4．2 iput（）函数——释放对一个inode对象的引用
当其他内核对象或模块不再需要一个inode对象时，必须通过iput（）函数，来解除对该inode对象的引用。
iput()函数将inode对象的引用计数减1。如果减到了0，则将该inode释放。否则就直接返回。
/**
* iput - put an inode
* @inode: inode to put
*
* Puts an inode, dropping its usage count. If the inode use count hits
* zero the inode is also then freed and may be destroyed.
*/

void iput(struct inode *inode)
{
if (inode) {
struct super_operations *op = NULL;

if (inode->i_sb && inode->i_sb->s_op)
op = inode->i_sb->s_op;
if (op && op->put_inode)
op->put_inode(inode);

if (!atomic_dec_and_lock(&inode->i_count, &inode_lock))
return;

if (!inode->i_nlink) {
list_del(&inode->i_hash);
INIT_LIST_HEAD(&inode->i_hash);
list_del(&inode->i_list);
INIT_LIST_HEAD(&inode->i_list);
inode->i_state|=I_FREEING;
inodes_stat.nr_inodes--;
spin_unlock(&inode_lock);

if (inode->i_data.nrpages)
truncate_inode_pages(&inode->i_data, 0);

if (op && op->delete_inode) {
void (*delete)(struct inode *) = op->delete_inode;
/* s_op->delete_inode internally recalls clear_inode() */
delete(inode);
} else
clear_inode(inode);
if (inode->i_state != I_CLEAR)
BUG();
} else {
if (!list_empty(&inode->i_hash)) {
if (!(inode->i_state & I_DIRTY)) {
list_del(&inode->i_list);
list_add(&inode->i_list,
&inode_unused);
}
inodes_stat.nr_unused++;
spin_unlock(&inode_lock);
return;
} else {
/* magic nfs path */
list_del(&inode->i_list);
INIT_LIST_HEAD(&inode->i_list);
inode->i_state|=I_FREEING;
inodes_stat.nr_inodes--;
spin_unlock(&inode_lock);
clear_inode(inode);
}
}
destroy_inode(inode);
}
}
对该函数的注释如下：
（1）函数首先调用超级块对象中的s_op->put_inode（）方法（如果有的话）来释放这个inode对象。
（2）通过atomic_dec_and_lock原子操作将I_count减1，并同时对inode_lock进行加锁。如果I_count在减1后还为非0值，则直接返回。否则就进行下面的处理。
（3）如果该inode的i_nlink值为0，则说明文件系统中已经没有任何文件链接到这个inode对象上。对于这种情况，iput()先将这个inode从其所属的哈希链表和“类型”链表中摘除。然后在其i_count中设置I_FREEING标志，表示正在释放这个inode对象。最后，看看是否定义了超级块对象方法s_op->delete_inode()，如果有则调用该方法删除相应的磁盘索引节点，如果未定义该方法，则调用clear_inode（）函数来清除这个inode对象。最后，用destroy_inode()将这个内存索引节点释放给inode_cachep slab分配器缓存。
（4）如果该inode的i_nlink不为0，则说明虽然没有人引用这个inode对象，但fs中还有文件链接与这个inode对象相关联，因此这个inode对象有可能再次被引用。对于这种情况，iput()函数首先判断这个inode对象是否正连接在哈希链表中。如果是，则将这个inode对象放到inode_unused链表中（当然，前提是这个inode对象不在s_dirty链表中，如果他在s_dirty链表中，则让他继续待在s_dirty链表中），然后直接返回就可以了。如果不是，则这个inode对象已经不用继续留在icache中了（反正通过哈希链表也找不到他），因此将这个inode对象从其所属的“类型”链表中摘除，然后调用clear_inode()方法清除这个inode对象，最后调用destroy_indoe（）将这个内存索引节点释放回inode_cachep slab分配器缓存。注意！这里不能调用超级块对象的delete_inode（）方法来删除对应的磁盘索引节点，因为fs中还有文件链接与这个inode相关联。

这篇专栏文章将讨论你能用allocator来做什么以及如何定义一个自己的版本。我只会讨论C++标准所定义的allocator：引入准标准时代的设计，或试图绕过有缺陷的编译器，只会增加混乱。

1 什么时候不使用Allocator

C++标准中的Allocator分成两块：一个通用需求集（描述于§ 20.1.5(表 32)），和叫std::allocator的class（描述于§20.4.1）。如果一个class满足表32的需求，我们就称它为一个 allocator。std::allocator类满足那些需求，因此它是一个allocator。它是标准程序库中的唯一一个预先定义 allocator类。

每个 C++程序员都已经知道动态内存分配：写下new X来分配内存和创建一个X类型的新对象，写下delete p来销毁p所指的对象并归还其内存。你有理由认为allocator会使用new和delete－－但它们没有。（C++标准将::operator new()描述为“allocation function”，但很奇怪，allocator并不是这样的。）

有关allocator的最重要的事实是它们只是为了一个目的：封装STL容器在内存管理上的低层细节。你不应该在自己的代码中直接调用 allocator 的成员函数，除非正在写一个自己的STL容器。你不应该试图使用allocator来实现operator new[]；这不是allocator该做的。 如果你不确定是否需要使用allocator，那就不要用。

allocator 是一个类,有着叫allocate()和deallocate()成员函数（相当于malloc和free）。它还有用于维护所分配的内存的辅助函数和指 示如何使用这些内存的typedef（指针或引用类型的名字）。如果一个STL容器使用用户提供的allocator来分配它所需的所有内存(预定义的 STL容器全都能这么做；他们都有一个模板参数，其默认值是std::allocator)，你就能通过提供自己的allocator来控制它的内存管 理。

这种柔性是有限制的：仍然由容器自己决定它将要申请多少内存以及如何使用它们。在容器申请更多的内存时，你能控制它调用那个低层函数，但是你不能通过使用 allocator来让一个vector行动起来像一个deque一样。虽然如此，有时候，这个受限的柔性也很有用。比如，假设你有一个特殊的 fast_allocator，能快速分配和释放内存（也许通过放弃线程安全性，或使用一个小的局部堆），你能通过写下std::list<T, fast_allocator<T> >而不是简单的std::list<T>来让标准的list使用它。

如果这看起来对你很陌生，那就对了。没有理由在常规代码中使用allocator的。

2 定义一个Allocator

以一个简单的例子开始。根据C++标准，std::allocator构建在::operator new()上。如果你正在使用一个自动化内存使用跟踪工具，让std::allocator更简单些会更方便。我们可以用malloc()代替:: operator new()，而且我们也不考虑（在好的std::allocator实作中可以找到的）复杂的性能优化措施。我们将这个简单的allocator叫作 malloc_allocator 。

既然malloc_allocator的内存管理很简单，我们就能将重点集中在所有STL的allocator所共有的样板上。首先，一些类型： allocator是一个类模板，它的实例专为某个类型T分配内存。我们提供了一序列的typedef，以描述该如何使用此类型的对象： value_type指T本身，其它的则是有各种修饰字的指针和引用。

    template <class T> class malloc_allocator

    {

    public:

      typedef T                 value_type;

      typedef value_type*       pointer;

      typedef const value_type* const_pointer;

      typedef value_type&       reference;

      typedef const value_type& const_reference;

      typedef std::size_t       size_type;

      typedef std::ptrdiff_t    difference_type;

      ...

    };

为什么有这么多的typedef？你可能认为pointer是多余的：它就是value_type *。绝大部份时候这是对的，但你可能有时候想定义非传统的allocator，它的pointer是一个pointer-like的class，或非标的 厂商特定类型value_type __far *；allocator是为非标扩展提供的标准hook。不寻常的pointer类型也是存在address()成员函数的理由，它在 malloc_allocator中只是operator &()的另外一种写法：

    template <class T> class malloc_allocator
    {
    public:
      pointer address(reference x) const { return &x; }
      const_pointer address(const_reference x) const {
        return &x;
      }
      ...

    };

我们也传给deallocate()两个参数：当然一个是指针，但同样还有一个元素计数值。容器必须自己掌握大小信息；传给allocate和 deallocate的大小参数必须匹配。同样，这个额外的参数是为效率而存在的，而同样，malloc_allocator不使用它。

    template <class T> class malloc_allocator
    {
    public:
      pointer allocate(size_type n, const_pointer = 0) {
        void* p = std::malloc(n * sizeof(T));
        if (!p)
          throw std::bad_alloc();
        return static_cast<pointer>(p);
      }
      void deallocate(pointer p, size_type) {
        std::free(p);
      }
      size_type max_size() const {
        return static_cast<size_type>(-1) / sizeof(value_type);
      }
      ...
    };

C+ +语言提供一个机制以在特定的内存位置创建对象：placement new。如果你写下new(p) T(a, b)，那么你正在调用T的构造函数产生一个新的对象，一如你写的new T(a, b)或 T t(a, b)。区别是当你写new(p) T(a, b)，你指定了对象被创建的位置：p所指向的地址。(自然，p必须指向一块足够大的内存，而且必须是未被使用的内存；你不能在相同的地址构建两个不同的对 象。)。你也可以调用对象的析构函数，而不释放内存，只要写p->~T()。

这些特性很少被使用，因为通常内存的分配和初始化是一起进行的：使用未初始化的内存是不方便的和危险的。你需要如此低层的技巧的很少几处之一就是你在写一 个容器类，于是allocator将内存的分配与初始化解耦。成员函数construct()调用placement new，而且成员函数destory()调用析构函数。

    template <class T> class malloc_allocator
    {
    public:
      void construct(pointer p, const value_type& x) {
        new(p) value_type(x);
      }
      void destroy(pointer p) { p->~value_type(); }
      ...
    };

这些成员函数没有一个是static的，因此，容器在使用allocator前做的第一件事就是创建一个allocator对象－－也就是说我们应该定义 一些构造函数。但是，我们不需要赋值运算：一旦容器创建了它的allocator，这个allocator就从没想过会被改变。表32中的对 allocator的需求没有包括赋值。只是基于安全，为了确保没人偶然使用了赋值运算，我们将禁止掉这个可能自动生成的函数。

    template <class T> class malloc_allocator
    {
    public:
      malloc_allocator() {}
      malloc_allocator(const malloc_allocator&) {}
      ~malloc_allocator() {}
    private:
      void operator=(const malloc_allocator&);
      ...
    };

    template <class T>
    inline bool operator==(const malloc_allocator<T>&,
                           const malloc_allocator<T>&) {
      return true;
    }
    tmplate <class T>
    inline bool operator!=(const malloc_allocator<T>&,
                           const malloc_allocator<T>&) {
      return false;
    }

最后，我们到了allocator的定义体中一个微妙的部份：在不同的类型之间映射。问题是，一个allocator类，比如 malloc_allocator<int>，全部是围绕着单个value_type构建的：malloc_allocator< int>::pointer是int*，malloc_allocator<int>().allocate(1)返回足够容纳一个 int对象的内存，等等。然而，通常，容器类使用malloc_allocator可能必须处理超过一个类型。比如，一个list类，不分配int对象； 实际上，它分配list node对象。(我们将在下一段落研究细节。)于是，当你创建一个std::list<int, malloc_allocator<int> >时，list必须将malloc_allocator<int>转变成为处理list_node类型的 malloc_allocator。

这个机制称为重绑定，它有二个部份。首先，对于给定的一个value_type是X1的allocator类型A1，你必须能够写出一个 allocator 类型A2，它与A1完全相同，除了value_type是X2。其次，对于给定的A1类型的对象a1，你必须能够创建一个等价的A2类型对象a2。这两部 分都使用了成员模板，这也就是allocator不能被老的编译器支持，或支持得很差的原因。

    template <class T> class malloc_allocator
    {
    public:
      template <class X>
      malloc_allocator(const malloc_allocator<X>&) {}
      template <class X>
      struct rebind { typedef malloc_allocator<X> other; };
      ...
    };

如果有一个allocator类型A1，对应于另外一个value_type的类型是typename A1::template rebind<X2>::othere[注2]。正如你能将一个类型转换为另外一个，模板的转换用构造函数让你转换值：你可以写 malloc_allocator<int>(a)，无论a的类型是malloc_allocator<int>，或 malloc_allocator<double>，或malloc_allocator<string>。象往常一样， malloc_allocator的转换用构造函数用不着做任何事，因为malloc_allocator没有成员变量。

附带一提，虽然绝大多数的allocator有一个模板参数(allocator的value_type)，但这不是需求中的规定，只不过常常正巧如此。重绑定机制在多模板参数的allocator上也工作良好：

    template <class T, int flags> class my_allocator
    {
    public:
      template <class U>
      struct rebind { typedef my_allocator<U, flags> other; };
      ...
    };

    template<> class malloc_allocator<void>
    {
      typedef void        value_type;
      typedef void*       pointer;
      typedef const void* const_pointer;
    template <class U>
     struct rebind { typedef malloc_allocator<U> other; };
    };

就是它了！malloc_allocator的完备源码见Listing 1。

3 使用Allocator

std::vector<char, malloc_allocator<char> > V;

取代简单的std::vector<char>，或用

typedef std::list<int, mempool_allocator<int> > List;

List L(mempool_allocator<int>(p));

取代简单的std::list<int>。

但是你能做得更多。STL的卖点是它是可扩展性：正如你能写自己的allocator，你也能写你自己的容器类。如果你很小心, 并且你写的容器类使用它的allocator来处理所有的内存相关操作，那么别人将能够加入他们自己的用户自定义allocator。

诸如std::vector和std::list这样的容器类是很复杂的，而且大部分复杂性与内存管理无关。让我们以一个简单的例子开始，这样我们可以只 关注于allocator。考虑一个固定大小数组的类，Array，元素的个数是在构造函数中设定的，并且在此之后不会改变。(这有点像std:: valarray的一个简化版本。)它有二个模板参数，元素类型和allocator类型。

容器，和allocator一样，以巢式类型申明开始：value_type， reference，const_reference，size_type，difference_type，iterator，和 const_iterator。通常，这些类型中的绝大部分都可以直接从它的allocator中获得－－这也解释了为什么容器的value_type必 须和allocator中的相匹配。

当然，iterator类型通常不来自于allocator；通常iterator是一个类，完全取决于容器的内在表示。Array类比通常见到的容器简 单，因为它实际上将所有元素存储在单块连续内存中；我们只要维护指向内存块开始和结束处的两个指针。iterator就是指针。

在更进一步之前，我们必须决定：我们将怎样储存allocator？构造函数将接受一个allocator对象作为参数。我们必须在容器的整个生命期内保存它的一个拷贝，因为在析构函数中还需要它。

依感觉，这儿没什么问题：我们只要申明一个Allocator类型的成员变量，然后使用它。方法是正确的，但不爽。毕竟，在99％的时间里，用户都不想考 虑有关allocator的事；他们只会写Array<int>并使用默认值－－而默认的allocator可能是一个没有任何非 static 成员变量的空类。问题是即使Allocator是一个空类，这样的成员变量也会有开销。(这是C++标准所要求的。) 我们的Array类将会有三个word的开销，而不是两个。也许一个word的额外开销不是大问题，但总是不爽，它迫使所有用户为一个几乎从不使用的功能 承担了开销。

都很多方法来解决这个问题，其中一些使用了traits类和偏特化。或许最简单的解决方法就是使用（私有）继承而不是成员变量。编译器被允许优化掉空基类，而且时下绝大多数的编译器都这么做了。

我们最终能写下定义的骨架了：

    template <class T, class Allocator = std::allocator<T> >

    class Array : private Allocator

    {

    public:

      typedef T value_type;

     

      typedef typename Allocator::reference reference;

      typedef typename Allocator::const_reference

              const_reference;

      typedef typename Allocator::size_type size_type;

      typedef typename Allocator::difference_type

              difference_type;

      typedef typename Allocator::pointer       iterator;

      typedef typename Allocator::const_pointer const_iterator;

      typedef Allocator allocator_type;

      allocator_type get_allocator() const {

        return static_cast<const Allocator&>(*this);

      }

      iterator begin()             { return first; }

      iterator end()               { return last; }

      const_iterator begin() const { return first; }

      const_iterator end() const   { return last; }

      Array(size_type n = 0,

            const T& x = T(),

            const Allocator& a = Allocator());

      Array(const Array&);

      ~Array();

      Array& operator=(const Array&);

    private:

      typename Allocator::pointer first;

      typename Allocator::pointer last;

    };

构造函数初始化allocator基类，获得足够容纳n个元素的一块内存(如果我们正在写类似于vector的东西，我们可能申请更大些的内存以供增长 用)，然后遍历内存以创建初始化值的拷贝。唯一的问题是异常安全：如果某一个元素的构造函数抛出了一个异常，我们必须撤销我们所做的一切。

    template <class T, class Allocator>

    Array<T, Allocator>::Array(size_type n,

                               const T& x,

                               const Allocator& a)

      : Allocator(a), first(0), last(0)

    {

      if (n != 0) {

        first = Allocator::allocate(n);

        size_type i;

        try {

          for (i = 0; i < n; ++i) {

            Allocator::construct(first + i, x);

          }

        }

        catch(...) {

          for(size_type j = 0; j < i; ++j) {

            Allocator::destroy(first + j);

          }

          Allocator::deallocate(first, n);

          throw;

        }

      }

    }

析构函数比较简单，因为我们不需要担心异常安全：T的析构函数被假设为从不抛出异常。

    template <class T, class Allocator>

    Array<T, Allocator>::~Array()

    {

      if (first != last) {

        for (iterator i = first; i < last; ++i)

          Allocator::destroy(i);

        Allocator::deallocate(first, last - first);

      }

    }

    template <class T>

    struct List_node

    {

      T val;

      List_node* next;

    };

l 使用一个value_type是List_node<T>的allocator，为一个新节点分配内存。 l 使用一个value_type是T的allocator，在节点的val位置上构建新的元素。 l 将这个节点连接到适当的位置。

这个过程需要处理两个不同的allocator，其中一个是通过对另一个的重绑定而获得的。它对几乎所有程序都工作得很好，即使是将allocator用 于相当复杂的目的的程序。它所不能完成的是向allocator提供一些不寻常的指针类型。它明显依赖于能使用List_node<T> *类型的普通指针。

如果你极端野心勃勃，想将其它可能的指针类型传给allocator，一切都突然变得复杂多了－－从一个节点指向另一个节点的指针不再是 List_node<T> *或void *了，但它必须是能够从allocator获取的某个类型。直接实现是不太可能的：用一个不完全的类型实例化allocator是非法的，因此，除非 List_node已经被完整定义，否则无法谈论指向List_node的指针。我们需要一个精巧的申明顺序。

    template <class T, class Pointer>

    struct List_node

    {

      T val;

      Pointer next;

    };

    template <class T, class Alloc>

    class List : private Alloc

    {

    private:

      typedef typename Alloc::template rebind<void>::other 

              Void_alloc;

      typedef typename Void_alloc::pointer Voidptr;

      typedef typename List_node<T, Voidptr> Node;

      typedef typename Alloc::template rebind<Node>::other

              Node_alloc;

      typedef typename Node_alloc::pointer Nodeptr;

      typedef typename Alloc::template rebind<Voidptr>::other

              Voidptr_alloc;

      Nodeptr new_node(const T& x, Nodeptr next) {

        Alloc a = get_allocator();

        Nodeptr p = Node_alloc(a).allocate(1);

        try {

          a.construct(p->val, x);

        }

        catch(...) {

          Node_alloc(a).deallocate(p, 1);

          throw;

        }

        Voidptr_alloc(a).construct(p->next, Voidptr(next));

        return p;

      }

      ...

    };

如果你想写一个如同malloc_allocator这样简单的allocator，应该没有困难。(前提是你正在使用一个比较现代的编译器)。然而，如果你的心比较大，－－基于内存池的或支持非标指针类型的allocator－－情况就比较不令人满意了。

如果你想使用可能的类指针（pointer-like）类型，它必须支持哪些操作？它必须有一个null值吗？如果是的话，那个值应该如何书写？你能使用 类型转换吗？你如何在类指针对象与普通指针间进行转换？你必须要考虑操作指针时抛的异常吗？我在这最后一节提出了一些假设；C++标准没有指明这些假设的 对错。这些细节都留给了具体的标准库的实现，即使某个实现完全忽略可选指针类型也是合法的。C++标准还遗留了一些没有答案的问题，比如当一个 allocator的不同实例不可互换时，将发生什么。

幸运的是，情形并不象标准(§ 20.1.5,第4-5段)中的词汇所描述得那么可怕。标准留下没有答案的问题，是因为在制订标准时，C++标准化委员会对答案达不成共识；对 allocator的必要的经验还不存在。每个参与制订的人都认为这是一个临时的补丁，其中的含糊肯定将在将来的修订中被去除。

等一下，如果你关心可移植性，最好还是远离可选的指针类型，而，如果你乐意接受一些限制，就能安全地使用诸如mempool_allocator这样不同 对象实体间差别很大的allocator。所有主流标准库的实现现在都在某个方面不支持这样的allocator，而且不同实现间的差别不大。

正如容器接受一个allocator作为模板参数，容器的构造函数也接受一个allocator作为参数。容器保留这个参数的一份拷贝，并使用这个拷贝来处理所有的内存管理；容器的allocator一旦在构造函数中初始化完成，就终生不变。

唯一的问题是当你运行一个需要两个容器在内存管理上进行协同的操作时，会发生什么。在标准库中确实存在两个这样的操作：swap()（所有容器）和std::list::splice()。原理上，可以以这样几个不同的方式处理他们：

l 禁止在两个allocator不等价的容器间进行swap()和splice()。 l 在swap()和splice()中放入一个allocator等价性的测试。如果不等价，降格调用copy()和赋值运算。 l 只提供swap()：如同对容器中的数据一样，交换它们的allocator。(很难找出如何将它推广到splice上.它同样也带来一个问题：如何swap没有定义赋值运算符的东西？)

如果你能避免对可能具有不同allocator的容器使用swap()和splice()，一切都很安全。在实践中，我没有发现这会造成严重束缚：你需要严格练习安全使用诸如内存池这类特性，而你或许并不想不加选择地混用使用不同allocator的容器。

部分因为不熟悉，部分因为C++标准的要求并不令人满意，目前对allocator的绝大多数的使用都很简单。由于C++社群对allocator变得越来越熟悉，并且标准已被阐明，我们能期待更复杂的使用将会浮现。 Listing 1: A sample allocator based on malloc

template <class T> class malloc_allocator

{

public:

  typedef T                 value_type;

  typedef value_type*       pointer;

  typedef const value_type* const_pointer;

  typedef value_type&       reference;

  typedef const value_type& const_reference;

  typedef std::size_t       size_type;

  typedef std::ptrdiff_t    difference_type;

 

  template <class U>

  struct rebind { typedef malloc_allocator<U> other; };

 

  malloc_allocator() {}

  malloc_allocator(const malloc_allocator&) {}

  template <class U>

  malloc_allocator(const malloc_allocator<U>&) {}

  ~malloc_allocator() {}

 

  pointer address(reference x) const { return &x; }

  const_pointer address(const_reference x) const {

    return x;

  }

 

  pointer allocate(size_type n, const_pointer = 0) {

    void* p = std::malloc(n * sizeof(T));

    if (!p)

      throw std::bad_alloc();

    return static_cast<pointer>(p);

  }

 

  void deallocate(pointer p, size_type) { std::free(p); }

 

  size_type max_size() const {

    return static_cast<size_type>(-1) / sizeof(T);

  }

 

  void construct(pointer p, const value_type& x) {

    new(p) value_type(x);

  }

  void destroy(pointer p) { p->~value_type(); }

 

private:

  void operator=(const malloc_allocator&);

};

 

template<> class malloc_allocator<void>

{

  typedef void        value_type;

  typedef void*       pointer;

  typedef const void* const_pointer;

 

  template <class U>

  struct rebind { typedef malloc_allocator<U> other; };

};

 

 

template <class T>

inline bool operator==(const malloc_allocator<T>&,

                       const malloc_allocator<T>&) {

  return true;

}

 

template <class T>

inline bool operator!=(const malloc_allocator<T>&,

                       const malloc_allocator<T>&) {

  return false;

}

本文所讲例子均基于内核为2.4.20-8的RedHat 9 Linux操作系统.如果使用的是其他linux系统或是redhat其他版本,或其他内核,本文仅作参考--Jiarry(Jarry).

加载USB移动盘符以及软驱/光驱 首先打开终端并输入 # fdisk -l 通过查询盘符(用fdisk)列表来查看支持的分驱格式以及相关信息.Redhat9 默认自带的支持fat32,fat等. 输入 # cat /proc/filesystems 查看系统支持的格式，有vfat的话支持FAT/FAT32，有ntfs的话支持NTFS，有iso9660的话支持iso标准CD，有smbfs的话支持samba/Microsoft Windows Network；没有需要的文件系统的话，需要重编内核加以支持； 在mnt下建立一个文件夹 # mkdir /mnt/usb1 这个文件夹用来转载usb的数据.redhat中,mnt用来加载各种盘符.usb,floppy,cdrom都可以. 输入 mount -t vfat /dev/sda1 /mnt/usb1 这时输入mount挂载刚用fidsk查看到usb所在的位置,并装载入到刚建好的文件夹中. 输入 #cd /mnt/usb1 进入usb1文件夹,用# ls或dir查看一下列表吧,是否看见了usb里的文件了呢. cd是进入文件的明令于DOS下相同,ls与dir都能查看文件列表. 输入 #umount /mnt/usb1 卸载USB Linux下,退出光盘或软盘必须卸载才能拔出.USB使用完后最好也卸载再拔出. 显示中文 #mount -t vfat -o iocharset=gb2312,codepage=936 /dev/sda1 /mnt/usb1 前面加载后的文件无法正常显示中文名,加上 -o iocharset=gb2312或者utf8就可以显示中文名称了. 加载光驱 [root@localhost root]# mount -t vfat /dev/scd0 /mnt/cdrom 或者 #mount /mnt/cdrom 加载软驱 [root@localhost root]# mount -t vfat -o iocharset=gb2312 /dev/fd0 /mnt/floppy 或者 #mount /mnt/floppy 访问windows NTFS盘符 访问fat或者fat32格式，与访问USB移动驱动器几乎差不多,如. #mount -t vfat -o iocharset=gb2312,codepage=936 /dev/hda6 /mnt/winD 即将/dev/hda6也就是windows Ｄ加载至mnt/winD文件夹下. 访问NTFS格式 #mount -t ntfs -o iocharset=gb2312 /dev/hda8 /mnt/winH 前面通过 #cat /proc/filesystems 可以查看到redha默认不支持NTFS格式,使用过红旗的可能知道红旗是可以访问NTFS的.这样我们需要下载一个与此相应的版本.安装软件包 #rpm -ivh kernel-ntfs-2.4.20-8.i686.rpm (下载地址:根据系统内核找到不同的rpm安装包 http://linux-ntfs.sourceforge.net/rpm/redhat9.html ) 也可用双击的方式安装(redhat9的安装最好是将开发工具以及编辑工具全选上),安装后用 #cat /proc/filesystems 看下,就能发现ntfs了. 最后再用mount命令 #mount -t ntfs -o iocharset=gb2312 /dev/hda7 /mnt/winG 这样就可以装载各个NTFS的盘符.别忘了先在mnt下建立相应的文件夹. 自动加载windows盘符 可以在启动文件里加如mount命令,那样也可以.但我的做法是,在桌面建立一个可执行autoRun.sh文件,将mount命令写进该文件里,需要用到时双击该sh文件运行即可.如下 #[root@localhost root]# sh /root/.gnome-desktop/autoRun.sh #装载windows盘符 mount -t ntfs -o iocharset=gb2312 /dev/hda5 /mnt/winE mount -t ntfs -o iocharset=gb2312 /dev/hda6 /mnt/winF mount -t ntfs -o iocharset=gb2312 /dev/hda7 /mnt/winG mount -t ntfs -o iocharset=gb2312 /dev/hda8 /mnt/winH 只要将以上文件存成一个.sh文件,且给该文件可执行权限就行了.这样很方便吧,想用时执行该文件就可以了,卸载也可以按这样的方式. 说明：本例所讲对windows NTFS是只读模式,要写入要另外下载相应的包,但不建议写入.从windows下访问Linux也很简单,去google搜索一下,或是下载一个 (windows下看linux分区的软件 Paragon.Ext2FS.Anywhere.2.5.rar和explore2fs-1.00-pre4.zip)软件,那样就可以读写了.但最好只是导出一些文件,不要写入. 为了让更多处于初学阶段的朋友能更快的适应并熟练使用Linux,也为了让自己加深记忆.特将自己在使用Linux过程中的遇到问题以及解决方案整理出来,以供大家参考.同时也备日后查阅.我知道大部分朋友与我一样都是从Windows下转入Linux的,而且仍然继续在使用Windows,都装了双系统.那我希望自己以及与我同样喜欢学习新知识的朋友在掌握Windows的情况下,能尽快掌握Linux.

find
[语法]: find 路径名... 表达式
[说明]: find 命令递归地遍历指定路径下的每个文件和子目录，看该文件是否能使表达式值为真，以下 n 代表一个十进制整数，+n 代表打印 n ， -n 代表小于 n ，下面是合法表达式说明：
-name 模式 文件名与模式匹配则为真，(\ 为转意符)
-perm [-]八进制数 文件存取模式与八进制数相同则为真若有- 选项，则文件存取模式含有八进制数规定模式即为真
-size n[c] 文件块长度为 n 则真(一块为512字节)，若有c 选项，则文件字节长度为 n 则真
-atime n 若文件的最近访问时间为 n 天前则为真，find 命令将改变其访问的目录的访问时间
-mtime n 若文件的最近修改时间为 n 天前则为真
-ctime n 若文件状态为 n 天前改变则为真
-exec 命令 { }\; 若命令返回值为0则真，{ }内为命令参数，此命令必须以 \; 为结束
-ok 命令 { }\; 与 exec 相同，只是在命令执行前先提示，若回答 y 则执行命令
-print 显示输出使表达式为真的文件名
-newer 文件 若文件的访问时间比newer 指定的文件新则真
-depth 先下降到搜索目录的子目录，然后才至其自身
-mount 仅查找包含指定目录的文件系统
-local 文件在当前文件系统时为真
-type c 文件类型为 c 则真，c 取值可为 b(块文件) c (字符文件) d(目录) l (符号链接) p (命名管道) f (普通文件)
\( 表达式 \) 表达式为真则真
-links n 文件链接数为 n 时为真
-user 用户 当文件属于用户时为真，用户可用数字表示UID
-nouser 当文件不属于 /etc/passwd 中的一个用户时为真
-group 文件组 当文件属于文件组时为真，文件组可用数字表示GID
-nogroup 当文件不属于 /etc/group 中的一个组时为真
-fstype 类型 当文件所属文件系统类型为指定类型时真
-inum n 当文件 i 节点号为 n 时为真
-prune 当目录名与模式匹配时，不再搜索其子目录
可以用逻辑操作符将简单表达式连接成复杂表达式
逻辑操作符有 ! 表示非操作， -o 表示或操作，两个表达式并列则表示与操作
[例子]:
find / -name find* -print
从根目录开始搜索文件名如 find* 的文件并显示之
find ./ -exec sleep{1}\; -print
每秒显示一个当前目录下的文件
find $HOME \(-name a.out -o -name '*.o' \) -atime +7 -exec rm {} \;
从$HOME目录开始搜索，删除所有文件名为a.out 或 *.o 且访问时间在7天前的文件

finger - 显示用户信息
finger命令比who命令显示的信息量大，功能强。基本使用方法如下
显示登录信息： finger
显示smith用户详细信息： finger smith

tar
[语法]: tar -c[vwfbL] [设备] [块] 文件...
tar -r[vwfbL] [设备] [块] 文件...
tar -t[vfL] [设备] [文件...]
tar -u[vwfbL] [设备] [块] 文件...
tar -x[lmovwfL] [设备] [文件...]
[说明]: 将多个文件归档，命令中各参数的意义为：
r 附加方式归档
x 抽取文件
t 显示文件
u 附加方式归档，同时删除旧版文件
c 建立新档案文件
v 显示所处理的文件名
w 处理文件前，要求用户确认
f 文件名 使用指定文件名作为档案文件
bn 每次读写 n 块，缺省值为1，最大值为20
m 将新的文件修改时间设为获取时的时间
o 获取出来的文件以下达tar指令的UID和GID存储
[例子]:
tar cvf file.tar *
tar tvf file.tar

cat file1 file2 file3 > file4

cat *.txt > file4

date

df

diff

touch

wc