一、关于目录

　　不管是何种操作系统，一提到其中的文件系统首先想到的自然是目录和文件。在Unix系统中一切皆可视为文件，目录是一种特殊的文件。在笔者前已发表的《Unix操作系统的入门与基础》一文中，曾介绍过用户主目录、工作目录以及绝对路径、相对路径的概念，我们也已经知道了使用pwd命令可以获得当前工作目录的绝对路径，那么如何在程序中实现类似于pwd命令的功能呢？这里需要用到getcwd()函数，它的定义是：
   
　　#include <unistd.h>
　　char* getcwd(char* buf, size_t size);  //成功返回buf,失败返回NULL
   
此函数中的第一个参数buf数组用于存放当前工作目录路径名的字符串，size是指这个buf数组最多能装多少数据，而函数返回值与放入buf中的内容是相同的。要注意的是，该缓存必须有足够的长度以容纳绝对路径名再加上一个“/0”终止字符，否则将会返回出错。
　　对于目录的操作，最常见的就是打开目录、读取目录信息、关闭目录，与之对应的函数分别是：

　　#include <sys/types.h>
　　#include <dirent.h>
　　DIR* opendir(const char* dirname);    //成功时返回指针，失败返回NULL
　　struct dirent* readdir(DIR* dirp);         //成功时返回指针，失败返回NULL
　　int closedir(DIR* dirp);                      //成功时返回0，失败返回-1
  
使用opendir()函数打开不存在的目录或者对目录没有访问权限，以及对普通文件使用此函数都将返回NULL。opendir()函数成功操作后将返回指向DIR结构的指针，而DIR结构用来保存被读取目录的相关信息。定义在头文件<dirent.h>中的dirent结构最常用到的成员是d_name，它可以保存文件名。
　　现来看下面的一个例程序：
　　[程序1]

　　#include <iostream>
　　#include <unistd.h>
　　#include <sys/types.h>
　　#include <dirent.h>
　　#include <errno.h>
　　using namespace std;
　　int main()
　　{
　　　　DIR* dp;
　　　　cout << " Please enter a dir name: ";
　　　　char name[255];
　　　　memset(name,0x00,255);
　　　　cin >> name;
　　　　cout << " ----------------- " << endl;
　　　　dp = opendir(name);
　　　　if(dp == NULL)
　　　　{
　　　　　　cout << errno << " [" <<strerror(errno) << "]" << endl;
　　　　　　return -1;
　　　　}
　　　　dirent* dirp;
　　　　while((dirp = readdir(dp))!= NULL)
　　　　{
　　　　　　cout << dirp->d_name << endl;
　　　　}
　　　　closedir(dp);
　　　　return 0;
　　}
 
　　在Unix系统中，一旦出现程序执行失败的情况，系统会自动设置一个名为errno的全局变量，用于记录错误的出错ID号。使用strerror(errno)可以获得指定错误的描述信息，不过在此之前一定要包含errno.h的头文件。编译执行程序1时，如果输入一个已存在且有访问权限的目录名，程序会列出此目录下的所有子目录名以及文件名；如果输入的是一个文件名，则会输出20 [Not a directory]；如果输入的是一个不存在的目录名，则会输出2 [No such file or directory]。
 
                                     　　　　　　二、关于文件

　　在介绍文件之前，先来引入文件描述符这一概念。文件描述符是一非负整数，内核以此来标识一个特定进程正在操作的文件。每当打开一个现存文件或创建一个新文件时，内核将向进程返回一个文件描述符，以供读、写文件时使用。对于进程而言，内核会在每个进程空间中维护一文件描述符表，所有打开的文件都将通过此表中的文件描述符来引用。
　　按照规定，文件描述符0与标准输入cin相对应，1与标准输出cout相对应，2与标准出错输出cerr相对应。除此之外，文件描述符表中的每一文件描述符都对应着文件表中的一个文件表项。内核为所有已打开的文件维护一张文件表，每个文件表项包含文件状态标志（读、写、增写、同步、非阻塞等）、当前文件位移量、V节点指针，其中V节点指针指向V节点表。V节点表由V节点项组成，每一V节点项中主要包含V节点信息、I节点信息（包括文件所在的设备、文件存储在硬盘的某一扇区某一磁道等信息）、当前文件长度等。在Unix系统中，一个文件对应着V节点表中惟一的一个V节点项。也就是说，如果两个独立的进程打开同一个文件，在文件表中会有两个文件表项，但这两个文件表项都指向同一个V节点表项。图1显示了文件描述符表、文件表、V节点表三者之间的关系。
   
        
　　如果两个独立的进程各自打开了同一文件，则文件描述符表、文件表、V节点表三者之间的关系如图2中所示。

    
    
　　Unix系统中文件I/O只需用到5个函数：open、read、write、lseek和close。下面将一一进行介绍。
   
　　1、open函数可以打开或创建一个文件，它的定义是：
   
　　#include <sys/types.h>
　　#include <sys/stat.h>
　　#include <fcntl.h>
　　int open(const char* pathname, int oflag, ...); //成功时返回文件描述符，失败返回-1
 
　　使用open函数成功时返回的文件描述符一定是最小的未用描述符数字。open函数的参数pathname是所要打开或创建的文件的名称，可以是相对路径，也可以是绝对路径，不给路径时默认为当前目录。参数oflag由一个或多个选择项组成，用以指明打开的模式，常用的有O_RDONLY（只读）、O_WRONLY（只写）、O_RDWR（可读可写），此三项互相排斥，我们使用时应该指定为其中的一项。此外，还有以下一些选择项可以选择：O_APPEND（每次写入的数据都加到文件的尾端）、O_CREAT（若文件不存在则创建它；使用此选择项时，需同时提供第三个参数来说明该新文件的存取权限）、O_EXCL（与O_CREAT一起使用时，文件不存在则创建文件，若文件已存在则报错）。open函数的第三个参数写为...，是因为仅当创建新文件时才使用此参数，用以表示所创建文件的访问权限，如0700代表只有用户自身可读可写可执行，其他人无权访问。
　　[程序2]
 
　　#include <iostream>
　　#include <unistd.h>
　　#include <sys/types.h>
　　#include <sys/stat.h>
　　#include <fcntl.h>
　　#include <errno.h>

　　using namespace std;

　　int main()
　　{
　　　　int i = open("info.txt",O_RDWR);
　　　　cout << "fd = " << i << endl;

　　　　int ii = open("new.txt", O_CREAT|O_EXCL,0700);
　　　　if(ii<0) cout << strerror(errno) << endl;
　　　　else     cout << "Create file successful" << endl;

　　　　return 0;
　　}
 
　　假设当前目录中已存在文件info.txt，编译执行程序2，大家会看到如下的运行结果：
 
　　fd = 3
　　Create file successful
 
　　再次执行程序2，运行结果则是：
 
　　fd = 3
　　File exists
  
　　2、close函数可以关闭一个打开的文件，它的定义是：
 
　　#include <unistd.h>
　　int close (int fd)； //成功返回0，失败返回-1
 
　　使用close函数关闭一个文件的同时也会释放该文件上的所有记录锁。不过，当一个进程终止时，它所有的打开文件都由内核自动关闭，因此程序通常利用这一特性而不用显式调用close来关闭文件了。
 
　　3、read函数可以从打开的文件中读取数据，它的定义是：
 
　　#include <unistd.h>
　　ssize_t read(int fd, void* buf, size_t nbytes); //成功时返回真正读取的字节数，失败则返回-1
 
　　read函数是通过给定的文件描述符，在文件描述符所对应的文件表项中获得当前文件位移量，然后从文件的当前位移量处开始，读取给定长度的数据放入buf中。
 
　　4、write函数可以向打开的文件中写入数据，它的定义是：
 
　　#include <unistd.h>
　　ssize_t write(int fd, void* buf, size_t nbytes); //成功时返回真正写入的字节数，失败则返回-1
 
　　write函数是从文件的当前位移量处开始，将buf中的数据写入文件中。下面将程序2中的代码做一修改，并假设info.txt文件中已有数据ABCDE。
　　[程序3]
 
　　#include <iostream>
　　#include <unistd.h>
　　#include <sys/types.h>
　　#include <sys/stat.h>
　　#include <fcntl.h>
　　#include <errno.h>

　　using namespace std;

　　int main()
　　{
　　　　int i = open("info.txt",O_RDWR);
　　　　cout << "fd = " << i << endl;

　　　　int ii = open("New.txt", O_CREAT|O_EXCL,0700);
　　　　if(ii<0) cout << strerror(errno) << endl;
　　　　else     cout << "Create file successful" << endl;

　　　　char buf[500];
　　　　memset(buf,0x00,500);
　　　　cout << read(i,buf,500) << "\t";
　　　　cout << buf << endl;
　　　　memset(buf,0x00,500);
　　　　read(0,buf,500);                           //从键盘读取数据
　　　　cout << write(1,buf,strlen(buf)) << endl;  //向屏幕写入数据
　　　　return 0;
　　}
 
　　编译执行程序3，大家会看到如下的运行结果：
 
　　fd = 3
　　File exists
　　6    ABCDE
　　12345   (键盘输入)
　　12345
　　6
 
　　5、lseek函数可以对一个打开文件的当前位移量进行显式地调整，它的定义是：
 
　　#include <sys/types.h>
　　#include <unistd.h>
　　off_t lseek(int fd, off_t offset, int whence);  //成功时返回新的文件位移量，失败则返回-1
 
　　在上文中我们已多次提到“当前文件位移量”这一名词，这里再作一简要解释。当前文件位移量是一非负整数，用以度量从文件开始处到某一位置的字节数。每个打开文件，都有一个与其相关联的“当前文件位移量”。打开一个文件时，除非指定O_APPEND选择项，否则系统默认该位移量被设置为0。通常，读、写操作都从当前文件位移量处开始，并使位移量增加所读或写的字节数。lseek函数中的第二参数是表示将要移动的字节数，第三个参数是移动的策略。若whence是SEEK_SET，则将该文件的位移量设置为距文件开始处offset个字节；若whence是SEEK_CUR，则将该文件的位移量设置为其当前值加offset, offset，可为正或负；若whence是SEEK_END，则将该文件的位移量设置为文件长度加offset, offset，可为正或负。
　　大家可能会对上述中的一种情况感兴趣，那就是采用SEEK_END再往后移动会出现怎么样的情况呢？带着这个问题，我们对程序3做如下修改。
　　[程序4]
 
　　#include <iostream>
　　#include <unistd.h>
　　#include <sys/types.h>
　　#include <sys/stat.h>
　　#include <fcntl.h>
　　#include <errno.h>

　　using namespace std;

　　int main()
　　{
　　　　int i = open("info.txt",O_RDWR);
　　　　cout << "fd = " << i << endl;

　　　　int ii = open("New.txt", O_CREAT|O_EXCL,0700);
　　　　if(ii<0) cout << strerror(errno) << endl;
　　　　else cout << "Create file successful" << endl;

　　　　char buf[500];
　　　　memset(buf,0x00,500);
　　　　cout << read(i,buf,500) << "\t";
　　　　cout << buf << endl;
　　　　memset(buf,0x00,500);
　　　　read(0,buf,500);
　　　　cout << write(1,buf,strlen(buf)) << endl;
 
　　　　errno = 0;
　　　　lseek(i,3,SEEK_SET);   //lseek(i,-3,SEEK_SET); //lseek(i,3,SEEK_END);
　　　　if(errno != 0) cout << strerror(errno) << endl;
　　　　write(i,buf,strlen(buf)-1);  //strlen(buf)-1表示去掉回车
　　　　return 0;
　　}
 
　　编译执行程序4，运行结果是（info.txt文件中的内容是ABCDE）：
 
　　fd = 3
　　File exists
　　6      ABCDE
　　abcde （键盘输入）
　　abcde
　　6
 
　　使用命令cat info.txt查看文件中的内容是：ABCabcde。
　　如果将程序中lseek语句换成“lseek(i,-3,SEEK_SET);”，重新编译执行。我们在键盘输入12345后，会提示Invalid argument。不过查看info.txt文件，会发现其中的内容已变成：ABCabcde12345。由此可知，负数不能与SEEK_SET一起使用，系统在提示错误的同时，会自动将写入的数据追加在文件末尾。
　　把程序中的lseek语句再改成lseek(i,3,SEEK_END)，重新编译执行。由键盘输入xyz后，查看文件内容是ABCabcde12345xyz，但会发现文件的大小由13变成19。使用命令od -c info.txt，会发现在xyz之前有三个\0。由此可知，在文件结尾处继续向后移动，如果写入数据则会自动在此前补入\0，这种文件被称为空洞文件。

    　Unix环境高级程序设计是一种难度较大的编程技术，它在软件开发领域的用途十分广泛。目前虽处于“曲高和寡”的状况，但却是程序员不断进阶的“利器”。笔者愿将个人对此的学习所得，分期总结整理后与有志深造者共享互助，携手前行。这一系列文章拟从整体上有着连贯性，而各篇又有相对独立性。文章中若涉及到前已发布的《Unix操作系统的入门与基础》、《Unix的轻巧“约取而实得”》中已解释的知识点，将不再赘述。读者阅读中如果遇到还不甚明了的概念，可以查阅本专栏中的上述文章。同时，本系列文章假设读者已熟悉C++语法，故不对涉及C++语法方面的知识进行解释。文中的代码已在SunOS 5.8中测试通过。

                                          一、在程序中使用环境变量

    　我们已经知道，环境变量可以用于定制用户的工作环境，即用环境变量可以保存用户对系统进行设置的信息。要想查看系统已定义的所有环境变量，可以使用setenv命令。那么，如何在程序中操作环境变量呢？
   　 在系统为每个程序分配的空间中，都会自动保存一份系统环境变量的拷贝。ANSI C中定义的两个函数getenv()和petenv()，分别可以用于获取环境变量的值和设置环境变量的值。这两个函数的定义分别是：

    　#include <stdlib.h>
    　char* getenv(const char* name); //成功返回指向环境变量值的指针，失败返回NULL
    　int putenv(const char* str);    //成功返回0，失败返回-1

我们通常使用getenv()从环境中获取一个指定的环境变量的值，使用putenv()来改变现有环境变量的值，或增加新的环境变量。putenv()参数形式为“name = value”的字符串，如果name指定的环境变量已经存在，则先删除其原来的定义再赋新值；如果不存在，则增加此环境变量。
    　现来看下面的一个例程序：
   　 [程序1]

 　　#include <stdlib.h>
 　　#include <iostream>
 　　using namespace std;

 　　int main()
 　　{
  　　　char* env = new char[255];
  　　　char* a = getenv("ABCDE");
  　　　if(a!=NULL)
   　　　　strcpy(env,a);
  　　　cout << "env: " << env << endl;
 　　　 if(putenv("ABCDE=aaa")<0)
   　　　　exit(-1);
  　　　strcpy(env,getenv("ABCDE"));
  　　　cout << "--------------------" << endl;
  　　　cout << "env: " << env << endl;
  　　　delete env;
  　　　return 0;
　 　}

    　运行此程序，将会在程序空间的环境变量表中增加一个新的环境变量ABCDE，其值为aaa。请注意，程序是在系统为其所分配空间的环境变量表中增加环境变量，而不是在系统的环境变量表中增加环境变量。
   
                       　　　　　　二、获取系统相关信息

    　在Unix系统中定义的uname()函数，可以返回与主机和操作系统相关的信息。uname()的定义是：
 
    　#include <sys/utsname.h>
    　int uname(struct utsname* name);  //成功返回非负值，出错返回-1

    　通过参数向其传递一个utsname结构的地址，uname函数将负责填写此结构。utsname结构定义如下：
   
 　　struct utsname {
     　　char sysname[9];  // name of the operating system
  　　　char nodename[9];  // name of this node
  　　　char release[9];  // current release of operating system
  　　　char version[9];  // current version of this release
  　　　char machine[9];  // name of hardware type
　　 };  

    　utsname结构中的信息可用“uname -a”命令来显示，在程序中则可以如下方式来查看。
    　[程序2]
   
   　 #include <sys/utsname.h>
 　　#include <iostream>
 　　using namespace std;
 
 　　#define ERR_QUIT(arg) {cout << #arg << endl; exit(-1);}
 
 　　int main()
 　　{
 　　　 struct utsname buf;
  　　　if(uname(&buf) < 0) ERR_QUIT("uname error");
  　　　cout << "Operation System Name: " << buf.sysname << endl;
  　　　cout << "Node Name          : " << buf.nodename << endl;
 　　　 cout << "O.S. release level   : " << buf.release << endl;
  　　　cout << "O.S. Version level   : " << buf.version << endl;
  　　　cout << "Hardware type        : " << buf.machine << endl;
 　　　 return 0; 
 　　}

    　我们曾经介绍过使用hostname命令来获取主机名，而要在程序中得到主机名，则可以调用Unix系统提供的gethostname()函数，其实hostname命令就是调用了gethostname()函数。

 　　#include <unistd.h>
　　 int gethostname(char* name, int namelen); //成功返回0，失败返回-1
 
    　[程序3]
   
 　　#include <iostream>
 　　#include <unistd.h>
 　　#include <errno.h>
 　　using namespace std;
 
 　　#define ERR_QUIT(arg) {cout << #arg << endl; exit(-1);}

 　　int main()
 　　{
  　　　char buf[256];
  　　　if(gethostname(buf,255)<0)
 　　　 {
   　　　　cout << "ERR: " << strerror(errno) << " : " << errno << endl; 
   　　　　ERR_QUIT("gethostname error.");
  　　　}
  　　　cout << "HostName is : " << buf << endl;
  　　　return 0;
 　　}

                       　　　　　　三、获取用户相关信息

    　用户每次都需凭一个经系统确认的用户名登录系统，而每个用户名在系统中将对应一个惟一的用户ID。用户ID是一个数值，它用于向系统标识各个不同的用户。在程序中如果想要获得用户的登录名以及用户ID号，可以使用如下的函数：

   　 #include<pwd.h>
    　char* getlogin();   //得到用户登录名
    　int getuid();       //得到当前登录用户的用户ID号
    　int geteuid();      //得到当前运行该进程的有效用户ID号
    　struct passwd* getpwuid(int userid); //得到一个指向passwd结构的指针，该结构中包含用户相关信息的记录
    　passwd的结构如下表所示：
    　

说明	struct passwd成员
用户名	char* pw_name
密码	char* pw_passwd
用户ID	uid_t pw_uid
组ID	gid_t pw_gid
注释	char* pw_gecos
工作目录	char* pw_dir
初始shell	char* pw_shell

    
    　当用户登录后，系统会分配给每个用户一个组ID，它也是一个数值。一般来说，在Unix中的组可被用于将若干用户集合到某个课题或部门中去，这种机制允许同组的各个成员之间共享资源(例如文件)。当然，一个用户可以参加多个课题或项目，因此也就可以同时属于多个组。在程序中如果想要获得用户所属的组ID号，可以使用如下的函数：

    　#include <grp.h>
    　int getgid();   //得到当前登录用户的组ID号
    　int getegid();  //得到当前运行该进程的有效用户的组ID号
    　struct group* getpgrgid(int groupid);  //得到一个指向group结构的指针，该结构中包含用户组相关信息的记录
   　 group的结构如下表所示：
    　

说明	struct group成员
组名	char* gr_name
密码	char* gr_passwd
组ID	int gr_gid
指向各用户名的指针数组（其中各指针指向该组的用户名，数组以null结尾）	char** gr_mem

    
    　来看下面的例程序：
   　 [程序4]
    
 　#include <pwd.h>
　 #include <grp.h>
 　#include <unistd.h>
　 #include <iostream>
 　using namespace std;
 　int main()
　 {
     　struct passwd* pwd;
     　cout << "Login name: " << getlogin() << endl;
     　pwd = getpwuid(getuid());
     　if(pwd)
  　　　 cout << "Real user: " << getuid() << "(" << pwd->pw_name <<")" << endl;
     　pwd = getpwuid(geteuid());
    　 if(pwd)
         　cout << "Effective user: " << pwd->pw_name << endl;
         
     　struct group* grp;
     　grp = getgrgid(getgid());
     　if(grp)
   　　　cout << "Real group: " << getgid() << "(" << grp->gr_name << ")" << endl;
  　　grp = getgrgid(getegid());
     　if(grp)
   　　　cout << "Effective group: " << grp->gr_name << endl;
 }
 
　　通常情况下，有效用户ID等于登录用户ID，有效组ID等于登录用户组ID。但是如果某一文件的拥有者通过命令“chmod u+s filename”设置了一个特殊标志位，则任何运行此文件的用户有效ID都将变为该程序拥有者的ID。这一特殊标志位被称为设置-用户-ID(set-user-ID)位，其定义是“当执行此文件时，将进程的有效用户ID设置为文件的所有者”。类似的，还可以通过设置使得执行此文件的进程有效组ID变为文件所有者的组ID。
 
                           　　　　　 四、时间与日期的使用

    　由Unix内核提供的基本时间服务是自1970年1月1日00:00:00以来国际标准时间（UTC）所经过的秒数累计值，通常被称为日历时间。日历时间包括时间和日期，这种秒数是以数据类型time_t来表示的（在Solaris中time_t等同于long）。我们可以使用time()函数来获得表示当前时间和日期的秒值。time()函数的定义是：

   　 #include <time.h>
    　time_t time(time_t* mem);  //成功则返回时间值，出错返回-1；如果参数非NULL，则时间值也存放在由mem指向的单元内

    　因此，time()函数常有如下两种使用方法：
    　（1） time_t now1;
          　　time(&now1);
          　　cout << now1 << endl;
    　（2） time_t now2;
            　now2=time(NULL);
            　cout << now2 << endl;
   　 [程序5]
   
　 　#include <time.h> //#include <ctime>
 　　#include <iostream>
 　　using namespace std;
 
 　　int main()
 　　{
 　　 　time_t now;
  　　　if(time(&now)<0)
  　　　{
   　　　　cout << "error" << endl;
  　　　　 exit(-1);
  　　　}
  　　　cout << now << endl;
  　　　cout << ctime(&now) << endl;
  　　　exit(0);
 　　}
   
    　由于这种秒值的表示方式，不能直观的让人们明白当前的时间，因此通常需要再调用其它的时间函数来将其转换为人们可读的时间与日期。图1说明了各种时间函数之间的关系。


          　　　　　　　　 （图1）
    　函数localtime()和gmtime()可以将秒值转换成以年、月、日、时、分、秒、周日表示的时间，并将这些存放在一个tm结构中。tm结构定义如下：
   
 　　struct tm {
  　　　int tm_sec;     /* seconds after the minute: [0, 61] */
  　　　int tm_min;     /* minutes after the hour: [0, 59] */
  　　　int tm_hour;    /* hours after midnight: [0, 23] */
  　　　int tm_mday;    /* day of the month: [1, 31] */
 　　　 int tm_mon;     /* month of the year: [0, 11] */
  　　　int tm_year;    /* years since 1900 */
 　　　 int tm_wday;    /* days since Sunday: [0, 6] */
  　　　int tm_yday;    /* days since January 1: [0, 365] */
 　　　 int tm_isdst;   /* daylight saving time flag: <0, 0, >0 */
 　　};

    　localtime()和gmtime()之间的区别是:localtime将日历时间转换成本地时间(考虑到本地时区和夏时制标志)，而gmtime则将日历时间转换成国际标准时间的年、月、日、时、分、秒、周日。它们的定义如下：

    　struct tm* gmtime(const time_t* mem);
    　struct tm* localtime(const time_t* mem);

    　函数mktime()则正好相反，它是以存放有本地时间年、月、日等的tm结构作为参数，将其转换成time_t类型的秒值。mktime()函数的定义是：

   　 time_t mktime(struct tm* tmptr);  //成功返回日历时间，失败则返回-1 

    　函数asctime()和ctime()可以获得人们可读的时间字符串，表示形式如同使用date命令所获得的系统默认的时间输出形式。它们的定义如下：

   　 char* asctime(const struct tm* tmptr); //参数是指向存放有本地时间年、月、日等的tm结构的指针
    　char* ctime(const time_t* mem);   //参数是指向日历时间的指针

    　函数strftime()是最为复杂的时间函数，可用于用户自定义时间的表示形式。函数strftime()的定义如下：

    　size_t strftime(char* buf, size_t maxsize, const char* format,
                       const struct tm* tmptr);  //有空间则返回所存入数组的字符数，否则为0

自定义格式的结果存放在一个长度为maxsize的buf数组中，如果buf数组长度足以存放格式化结果及一个null终止符，则该函数返回在buf数组中存放的字符数(不包括null终止符)，否则该函数返回0。format参数用于控制自定义时间的表示格式，格式的定义是在百分号之后跟一个特定字符，format中的其他字符则按原样输出。其中特别应注意的是，两个连续的百分号则是表示输出一个百分号。常用的定义格式如下表所示。

格式	说明	例子
% a	缩写的周日名	Tue
% A	全周日名	Tuesday
% b	缩写的月名	Jan
% B	月全名	January
% c	日期和时间	Wed Aug 17 19:40:30 2005
% d	月日：[01, 31]	14
% H	小时（每天2 4小时）：[00, 23]	19
% I	小时（上、下午各1 2小时[01, 12]	07
% j	年日：[001, 366]	014
% m	月：[01, 12]	01
% M	分：[00, 59]	40
% p	A M / P M	PM
% S	秒:[00, 61]	30
% U	星期日周数：[00, 53]	02
% w	周日：[ 0 =星期日，6 ]	2
% W	星期一周数：[00, 53]	02
% x	日期	08/17/05
% X	时间	19:40:30
% y	不带公元的年：[00, 991]	05
% Y	带公元的年	2005
% Z	时区名	MST

    　下面再来看一个具体程序。在此程序中，如提供一个秒值作参数，则会依照自定义的格式输出日期与时间信息；如提供一个以年、月、日、时、分、秒为格式的参数，则会输出从1970年1月1日00:00:00以来国际标准时间（UTC）所经过的秒数累计值。
    　[程序6]
   
　　 #include <time.h>
 　　#include <iostream>
 　　#include <string>
 　　#include <cstdio>
 　　#include <stdexcept>
 　　using namespace std;
 
　　 void usage(char * proc)
　　 {
  　　　cout << " Usage: 1." << proc << " [YYYY MM DD HH MM SS] (HH -- In 24 hours format)" << endl;
  　　　cout << "        2." << proc << " [time in seconds]" << endl;
 　　}  
 
　　 int main(int argc, char* argv[])
 　　{
 　　　 if(argc == 1)
 　　　 {
   　　　　usage(argv[0]);
   　　　　return EXIT_FAILURE;
  　　　}
 
 　　　 if(argc == 2) //Case in 2
  　　　{
  　　　　 long transfer;
   　　　　transfer = atol(argv[1]);
 　　　　  struct tm* now = NULL;
  　　　　 now = localtime(&transfer);
   
   　　　　char timestamp[150];
   　　　　strftime(timestamp,sizeof(timestamp),"%Y-%m-%d %H:%M:%S",now);
   　　　　strcat(timestamp," (format in: YYYY-MM-DD HH:MM:SS)");
   　　　　cout << endl << "\tAfter convert: " << timestamp << endl << endl;
   　　　　return EXIT_SUCCESS;
 　　　 }
  　　　else //Case in 1
  　　　{
   　　　　if(argc != 7)
  　　　　 {
    　　　　　usage(argv[0]);
   　　　　　 return EXIT_FAILURE;
  　　　　 }
   　　　　try{
    　　　　　　struct tm* now = new struct tm;
    　　　　　　now->tm_year = atoi(argv[1]);
    　　　　　　now->tm_mon = atoi(argv[2]);
    　　　　　　now->tm_mday = atoi(argv[3]);
    　　　　　　now->tm_hour = atoi(argv[4]);
    　　　　　　now->tm_min = atoi(argv[5]);
    　　　　　　now->tm_sec = atoi(argv[6]);
    
    　　　　　　//Adjust
    　　　　　　now->tm_mon--;
    　　　　　　now->tm_year -= 1900;
    
    　　　　　　cout << endl << "\tAfter convert: " << mktime(now) << " (format in seconds since UTC)" << endl;
    　　　　　　delete now; 
   　　　　}catch(logic_error& e) {
    　　　　　　cout << e.what() << endl;
  　　　　 }
   　　　　return EXIT_SUCCESS;
  　　　}
  　　　return EXIT_SUCCESS;
 　　}

                         　　　　　  五、登录会计文件的使用

   　 Unix系统中提供了下列两个数据文件：
    　（1）utmp文件，用于记录当前登录系统的各个用户，它被放于/var/adm/utmpx；
    　（2）wtmp文件，用于跟踪所有登录与登出系统的事件，它被放于/var/adm/wtmpx。
    　此外，还定义了一个结构体utmpx，其包含了用户登录与登出系统的相关信息。用户每次登录系统，系统会自动填写这一结构，然后将其写入到utmp文件中，同时也将其添写到wtmp文件中。登出时，系统会将utmp文件中相应的记录擦除(每个字节都填以0)，并将一条新记录添写到wtmp文件中。另外，在系统再次启动以及更改系统时间和日期时，也都会在wtmp文件中添写特殊的记录项。
    　上述两个数据文件为二进制文件，人们要是直接打开会看到一堆的乱码，但可以通过who命令读utmp文件并以可读格式输出其内容，使用last命令可以查看wtmp文件中所有的记录。而在自己编写的程序中，则可以使用相应的函数来查看数据文件的实用信息，其程序如：
   
    　[程序7]
   
    　#include <iostream>
 　　#include <utmpx.h>
 　　#include <unistd.h>
 　　#include <errno.h>
 　　using namespace std;

 　　#define trace(arg) cout << #arg << " = " << (arg) << endl

 　　int main(int argc, char** argv)
 　　{
  　　　if(argc == 2) {
   　　　　utmpxname(argv[1]);  //打开新的记录文件，请注意由argv[1]参数指定的文件名必须以x结尾
 　　 　}
  　　　struct utmpx * tmp;
  　　　tmp = getutxent();    //getutxent()可以从wtmpx中获得一行数据记录，即一条登录或登出事件
  　　　while(tmp != NULL)
 　　　 {
        　　 trace(tmp->ut_user);     //登录账号
  　　　 　trace(tmp->ut_id);       //登录ID
   　　　　trace(tmp->ut_line);     //登录设备名，省略了“/dev/”
   　　　　trace(tmp->ut_pid);      //进程ID
   　　　　trace(tmp->ut_type);     //登录类型，7（或USER_PROCESS）代表登录，8（或DEAD_PROCESS）代表登出
   　　　trace(tmp->ut_tv.tv_sec); //执行当前操作时的时间记录
   　　　cout << "---------------" << endl;
  　　　 tmp = getutxent(); 
   　　　sleep(1);
 　　 　}
  　　　return 0;
 　　}
    
       运行此程序，会自动读取wtmp文件中的信息，并依照我们所定义的格式输出。再来看一个复杂点的例程序。
    　[程序8]

　　 #include <iostream>
　　 #include <utmpx.h>
　　 #include <unistd.h>
　　 #include <errno.h>
　　 using namespace std;

　　 void show(struct utmpx*& tmp)
　　 {
 　　　 cout << tmp->ut_user << endl;
 　　　 cout << tmp->ut_id << endl;
 　　　 cout << tmp->ut_line << endl;
  　　　cout << tmp->ut_pid << endl;
　　　  cout << tmp->ut_type << endl;
　　　  cout << tmp->ut_tv.tv_sec << endl; 
 　　}

 　　int main()
　　 {
 　　　 static int i=0;
  　　　struct utmpx * tmp;
  　　　struct utmpx * t = new utmpx;
 　　　 tmp = getutxent();
  　　　while(tmp != NULL)
 　　　 {
  　　　　 show(tmp);
  　　　　 cout << "______________" << endl;
  　　　　 tmp = getutxent(); 
  　　　　 sleep(1);
   　　　　if(++i == 7) break;
  　　　　 if(i == 5)
   　　　　{
    　　　　　cout << "************** " << endl;
    　　　　　memcpy(t,tmp,sizeof(struct utmpx));
    　　　　　show(t); 
    　　　　　cout << "************** " << endl;
   　　　　}
 　　　 }
  　　　struct utmpx* ll;
  　　　setutxent();                        //将当前文件位移量置0，即从文件头部重新开始读第一条记录
 　　　 cout << "************** " << endl;
  　　　ll = getutxline(t);                 //找到与t的ut_user相同、ut_type也相同的第一条记录
  　　　show(ll);
 　　　 cout << "************** " << endl;
  　　　while(1)
 　　　 {
  　　　　 ll = getutxent();
  　　　　 show(ll);
  　　　　 if(ll->ut_type == USER_PROCESS || ll->ut_type == DEAD_PROCESS)
   　　　　{
    　　　　　memcpy(t,ll,sizeof(struct utmpx));
    　　　　　break;
  　　　　 }
 　　　 }
  　　　utmpxname("utmp.bakx");             //打开一个新的记录文件，请注意文件名必须以x结尾
  　　　cout << " the following will be write into .. \n";
 　　　 show(t);
  　　　pututxline(t);                      //将t指向的记录写入新的记录文件
  　　　endutxent();                        //关闭文件流
  　　　delete t;
  　　　return 0;
　　 }

   　每个人都有打电话的经历，在我们拨打电话时会进入电信计费系统，一旦拨通电话则系统会记录登录时间，挂断电话则系统会记录退出时间，两时间差即为用户的通话时长。那么在每个月底将某一用户的通话记录搜索出来放入一个新的记录文件，并将其打印出来便是用户的每月通话账单了。因此，Unix的登录会计文件完全可以用于电信服务中的数据采集工作，电信的数据采集系统可能也正是采用了类似的方式。