标签归档:c++

基于DOS的多任务系统

-操作系统作业- = =
主要有线程的创建和撤销、线程的调度、线程的阻塞和唤醒、线程的同步与互斥、利用消息缓冲队列通信机制实现线程间通信这几块。

代码如下:turboc2下测试通过

 

#include 
/*#include */
#include 
#include 
#include 

#define NTCB 5 /*最多任务数*/
#define TC 2	/*定义时间片长度*/
#define NBUF 6	/*定义缓冲区大小*/
#define NTEXT 20

/*状态码常量定义*/
#define FINISHED 0
#define RUNNING 1
#define READY 2
#define BLOCKED 3

/*INDOS标志*/
#define GET_INDOS 0x34
#define GET_CRIT_ERR 0x5d06

char far *indos_ptr = 0;/*存放INDOS标志的地址*/
char far *crit_err_ptr = 0; /*存放严重错误标志的地址*/

/*全局变量*/
int n=0;
int current =0;
int timecount = 0;
int TL = 10;




typedef int(far *codeptr)(void);

typedef struct 
{
	int value;
	struct TCB *wq;

}semaphore;

semaphore mutexfb={1,NULL};/* buf[] is a critical resource */
semaphore sfb={NBUF,NULL};/* buf[] */
semaphore mutex={1,NULL};
semaphore sa={1,NULL},sb={0,NULL};

struct TCB{
	unsigned char *stack; /*线程堆栈的其实地址*/
	unsigned ss; /*堆栈段制*/
	unsigned sp; /*堆栈指针*/
	char state; /*堆栈状态,取值为状态符*/
	char name[10]; /*线程外部标识符*/
	struct buffer *mq;
	semaphore     mutex;
	semaphore     sm;
	struct TCB *next;
} tcb[NTCB];

struct int_regs{
	unsigned bp,di,si,ds,es,dx,cx,bx,ax,ip,cs,flags,off,seg;
};



struct buffer {
  int id;
  int size;
  char text[NTEXT];
  struct buffer *next;
} buf[NBUF],*freebuf;



int InitTcb();
int create(char *name,codeptr code,int stck);
void destory(int id);
void interrupt swtch(void);
void interrupt new_int8(void);
void over();
int all_finished(void);
void InitDos(void);
int DosBusy(void);
void interrupt (*old_int8)(void);
void block(struct TCB **qp);
void wakeup(struct TCB **qp);
void p(semaphore *sem);
void v(semaphore *sem);
void wait(int delay);
void send(char *receiver,char *a,int size);
int receive(char *sender,char *b);
void init_main();


int InitTcb() /*初始化tcb*/
{
	int i;
	for(i=0;iip = FP_OFF(code);
    pp->cs = FP_SEG(code);
    pp->ds = _DS;
    pp->es = _DS;
    pp->flags = 0x200;/*flags寄存器 存放中断变量地址*/
    pp->off=FP_OFF(over); /*执行over函数*/
	pp->seg=FP_SEG(over);
    tcb[id].state = READY;
    /*for(i=0;i<10;i++)
    {
    	tcb[id].name[i] = *name;
	if((++name) == '\0');
    	break;
    }
    tcb[id].name[9] = '\0';*/
	strcpy(tcb[id].name,name);
	 enable();
	 printf("thread pid = %d,name = %s  craeted\n",id,name);
	 return(1);

}
void destory(int id)
	{
		disable();
		free(tcb[id].stack);
		tcb[id].stack = NULL;
		tcb[id].state = FINISHED;
		tcb[id].name[0] = '\0';
		printf("\n_______thread %d destory______\n",id);
		enable();

	}


void over()  /*函数执行结束的销毁线程*/
{
	destory(current);
	swtch();
	printf("____now n = %d\n____",n );
}

int all_finished(void)
{
  int i=1;
  for(i=1;inext!=NULL) 
    	tcbp=tcbp->next;
      tcbp->next=&tcb[id];
    }
    tcb[id].next=NULL;
    swtch();
    enable();




}
void wakeup(struct TCB **qp) /*唤醒*/
{
	int i;
	struct TCB *tcbv;

	disable();
    if((*qp)==NULL) return;
    tcbv=(*qp);
    (*qp)=(*qp)->next;
    tcbv->state=READY;
    tcbv->next=NULL;
	enable();



}

void p(semaphore *sem)
{
	struct TCB **qp;

	disable();
	sem->value = sem->value-1;
	if(sem->value<0)
	{
		qp = &(sem->wq);
		block(qp);
	}
	enable();
}


void v(semaphore *sem)
{
	struct TCB **qp;

	disable();
	qp = &(sem->wq);
	sem->value=sem->value+1;
	if(sem->value<=0)
    wakeup(qp);
	enable();
}
void wait(int delay)
{long i,j,k;
	for(i=0;inext;
  return(buff);
}

void insert(struct buffer **mq,struct buffer *buff)
{ struct buffer *temp;

  if(buff==NULL) return;
  buff->next=NULL;
  if(*mq==NULL)
    *mq=buff;
  else{
    temp=*mq;
    while(temp->next!=NULL)
      temp=temp->next;
    temp->next=buff;
  }
}

struct buffer *remov(struct buffer **mq,int sender)
{
  struct buffer *p,*q,*buff;
  q=NULL;
  p=*mq;
  while((p->id!=sender)&&(p->next!=NULL)){
    q=p;
    p=p->next;
  }
  if(p->id==sender){
    buff=p;
    if(q==NULL) *mq=buff->next;
    else q->next=buff->next;
    buff->next=NULL;
    return(buff);
  } else {
    return(NULL);
  }
}

void send(char *receiver,char *a,int size)
{
  struct buffer *buff;
  int i,id=-1;

  disable();

  for(i=0;iid=current;
  buff->size=size;
  buff->next=NULL;
  for(i=0;isize;i++,a++)
    buff->text[i]=*a;

  /*p(&tcb[id].mutex);*/
    insert(&(tcb[id].mq),buff);
  /*v(&tcb[id].mutex);*/
  v(&tcb[id].sm);

  enable();
}

int receive(char *sender,char *b)
{
  int i,size,id=-1;
  struct buffer *buff;

  disable();

  for(i=0;isize;
  for(i=0;isize;i++,b++)
    *b=buff->text[i];
  p(&mutexfb);
    insert(&freebuf,buff);
  v(&mutexfb);
  v(&sfb);

  enable();
  return(size);
}




void f1(void)
{ long i,j,k;
  for(i=0;i<1000;i++)
  {
    putchar('a');
    for(j=0;j<1000;j++)
      for(k=0;k<100;k++);
  }
}

void f2(void)
{ long i,j,k;
  for(i=0;i<100;i++)
  {
    putchar('b');
    for(j=0;j<1000;j++)
      for(k=0;k<100;k++);
  }
}

void f3(void)
{ long i,j,k;
  int temp;
  for(i=0;i<100;i++){
    temp=n;
    wait(5);
    temp++;
    n=temp;
    for(j=0;j<1000;j++)
      for(k=0;k<99;k++);
  }
}

void f4(void)
{ long i,j,k;
  int temp;

  for(i=0;i<100;i++){
    temp=n;
    temp++;
    wait(10);
    n=temp;
    for(j=0;j<1000;j++)
      for(k=0;k<100;k++);
  }
}


void f5(void)
{ long i,j,k;
  int temp;
  for(i=0;i<5;i++){
    p(&mutex);
      temp=n;
      wait(100);
      temp++;
      n=temp;
    v(&mutex);
	printf("[F5]now n = %d\n",n);
    for(j=0;j<1000;j++)
      for(k=0;k<99;k++);
  }
}

void f6(void)
{ long i,j,k;
  int temp;

  for(i=0;i<5;i++){
    p(&mutex);
      temp=n;
      temp++;
      wait(200);
      n=temp;
    v(&mutex);
	printf("[F6]now n = %d\n",n);
    for(j=0;j<1000;j++)
      for(k=0;k<100;k++);
  }
}

void f7(void)
{ long i,j,k;
  int temp;
  for(i=0;i<5;i++)
  {
    p(&sa);
      temp=n;
      temp++;
      wait(300);
      n=temp;
    v(&sb);
    printf("[3]%d\n",n );
  }
  
}
void f8(void)
{ long i,j,k;
  int temp;
  for(i=0;i<5;i++)
  {
    p(&sb);
      temp=n;
      temp++;
      wait(100);
      n=temp;
    v(&sa);
    printf("[4]%d\n",n );
  }

}

void sender(void)
{
  int i,j;
  char a[10];
loop:
  for(i=0;i<10;i++){
    strcpy(a,"message");
    a[7]='0'+n;
    a[8]=0;
    send("receiver",a,strlen(a));
    printf("sender:Message \"%s\"  has been sent\n",a);
    n++;
  }
  receive("receiver",a);
  if (strcmp(a,"ok")!=0){
    printf("Not be committed,Message should be resended!\n");/*接收进程没确认,需重新发送消息*/
    goto loop;
  }else printf("Committed,Communication is finished!\n");/*发送者得到接收者的确认,通信结束*/
}

void receiver(void)
{
  int i,j,size;
  char b[10];
  for(i=0;i<10;i++){
    b[0]=0;
    while((size=receive("sender",b))==-1);
    printf("receiver: Message is received--");/*已接收到消息--*/
    for(j=0;j7) ;
    switch(sele){
      case 1:
       create("f1",(codeptr)f1,1024);
       create("f2",(codeptr)f2,1024);
       /*clrscr();*/
       printf("\t No deprivation in two threads' concurrent running: \n");/*不剥夺方式下两个线索的并发执行*/
       printf("\t Thread f1 continuous output \'a\' 1000 times ;\n");/*其中线索f1不断输出字母a,共1000次*/
       printf("\t Thread f2 continuous output \'b\' 1000 times 。\n");/*而线索f2不断输出字母b,共100次*/
       printf("\t Press any key to continue!\n");/*按任意键继续*/
       getch();
       break;

      case 2:
       create("f1",(codeptr)f1,1024);
       create("f2",(codeptr)f2,1024);
      /*clrscr();*/
       printf("\t Round-Robin in two threads' concurrent running:\n");/*时间片轮转方式下两个线索的并发执行*/
       printf("\t Thread f1 continuous output \'a\' 1000 times ;\n");/*其中线索f1不断输出字母a,共1000次*/
       printf("\t Thread f2 continuous output \'b\' 1000 times 。\n");/*而线索f2不断输出字母b,共100次。*/
       printf("\t Please configurate the length of time slice(1/18.2):");/*请设置时间片的大小(单位为1/18.2秒)*/
       scanf("%d",&TL);
       printf("\t Press any key to continue!\n");
       getch();
       setvect(8,new_int8);
       break;

      case 3:
       n=0;
       create("f3",(codeptr)f3,1024);
       create("f4",(codeptr)f4,1024);
      /*clrscr();*/
       printf("\t Threads share critical resource(no mutual exclusion).\n");/* 线索同时共享临界资源的情况*/
       printf("\t Thread f3 and f4 share the same variable parameter \'n\';\n");/*线索f3和f4共享一变量n*/
       printf("\t Thread f3 continuous add 1 to \'n\' 100 times;\n"); /*times线索f3不断对n进行加1操作,共进行100次*/
       printf("\t Thread f4 also continuous add 1 to \'n\' 100 times;\n");/*线索f4也不断对n进行加1操作,共进行100次*/
       printf("\t Result should be 200.\n");/*因此,最后n的值应为200*/
       printf("\t Press any key to continue!\n");
       getch();
       TL=1;
       setvect(8,new_int8);
       break;

      case 4:
       n=0;
       create("f5",(codeptr)f5,1024);
       create("f6",(codeptr)f6,1024);
       clrscr();
       printf("\t Threads share critical resource(in mutual exclusion): \n");/*线索互斥共享临界资源*/
       printf("\t Thread f3 and f4 share the same variable parameter \'n\';\n");/*线索f3和f4共享一变量n*/
       printf("\t Thread f3 continuous add 1 to \'n\' 100 times;\n");/*线索f3不断对n进行加1操作,共进行100次*/
       printf("\t Thread f4 also continuous add 1 to \'n\' 100 times;\n");/*线索f4也不断对n进行加1操作,共进行100次*/
       printf("\t Result should be 200.\n");/*因此,最后n的值应为200*/
       TL=1;
       printf("\t Press any key to continue!\n");
       getch();
       setvect(8,new_int8);
       break;
      case 5:
       n=0;
       create("iop",(codeptr)f7,1024);
       create("cp",(codeptr)f8,1024);
       clrscr();
       printf("\t Computing process and Output process concurrently running wihtout synchronism: \n");/*没同步的计算进程和输出进程的并发执行*/
       printf("\t Computing process \'cp\' continuous calculate and put the result into a buffer,\n");/*并将其放入一缓冲区*/
       printf("\t Printing process \'iop\' orderly fetch \'cp\' and output it.\n");/*打印进程iop依次取出cp放入缓冲区中的数,将它输出出来*/
     printf("\t Here ,\'cp\' computed 10 results:0,1,2,3,4,5,6,7,8,9\n");/*本例中,cp计算出十个数,分别为0,1,2,3,4,5,6,7,8,9*/
       printf("\t Press any key to continue!\n");
       getch();
       TL=1;
       setvect(8,new_int8);
       break;
      case 6:
       n=0;
       create("f7",(codeptr)f7,1024);
       create("f8",(codeptr)f8,1024);
       clrscr();
       printf("\t Computing process and Output process concurrently running in synchronism: \n");/*经过同步的计算进程和输出进程的并发执行:*/
       printf("\t Computing process \'cp\' continuous calculate and put the result into a buffer,\n\n");/*计算进程cp不断计算数,并将其放入一缓冲区,*/
       printf("\t Printing process \'iop\' orderly fetch \'cp\' and output it.\n");/*打印进程iop依次取出cp放入缓冲区中的数,将它输出出来.*/
       printf("\t Here ,\'cp\' computed 10 results:0,1,2,3,4,5,6,7,8,9\n");/*本例中,cp计算出十个数,分别为0,1,2,3,4,5,6,7,8,9\n*/
       printf("\t Press any key to continue!\n");
       getch();
       TL=1;
       setvect(8,new_int8);
       break;
      case 7:
       init_buf();
       n=0;
       create("sender",(codeptr)sender,1024);
       create("receiver",(codeptr)receiver,1024);
       clrscr();
       printf("\t Communication among threads:\n");/*线索间的通信: */
       printf("\t Thread \'sender\' call primitive(send) to send 10 messages to \'receiver\';\n");/*线索sender调用send原语向线索receiver发送十个消息*/
     printf("\t The 10 messages are:message0,...,message9;\n");/*十个消息的内容分别为*/
       printf("\t Thread \'receiver\' call primitive(receive) to receiver  message from \'sender\';\n");/*线索receiver调用receive接收sender发来的消息*/
       printf("\t Here, message buffer has 5 units.\n");/*本例中,消息缓冲的个数为5个*/
       printf("\t Press any key to continue!\n");/*按任意键继续!\n");*/
       getch();
       TL=1;
       setvect(8,new_int8);
       break;

default:sele=0;
    }
    while(!all_finished());
    if(sele==3){
      printf(" The result of no mutual exclusion in shared critical resource:\n");/*因对临界资源的共享没互斥,本次运行的结果为*/
      printf("n==%d\n",n);
    }
    if(sele==4)
      printf("n==%d\n",n);
    if(sele!=0){
      printf("All of the threads are terminated expect \'0\',press any key to quit system!\n");/*除0号线索外,其余线索都已执行完毕,请按任意键结束! ;*/
      getch();
    }
    setvect(8,old_int8);
  }
  printf("\t\tThe multi-task system is terminated\n");/*多任务系统结束运行*/

}

C++递归调用遍历目录树

#include
#include
/* 预处理申明 */
//#pragma comment (lib, "User32.lib")

/* 函数申明 */
DWORD ListAllFileInDrectory(LPSTR szPath);

/* 全局变量 */
//记录所有的文件和目录数
DWORD dwTotalFileNum = 0;

/* ************************************
* DWORD ListAllFileInDrectory(LPSTR szPath)
* 功能 遍历目录及所有子目录,打印路径
*
* 参数 LPTSTR szPath,为需遍历的目录
*
* 返回值 0代表执行完成,1代码发生错误
**************************************/
DWORD ListAllFileInDrectory(LPSTR szPath)
{
CHAR szFilePath[MAX_PATH];

WIN32_FIND_DATA FindFileData;
HANDLE hListFile;
CHAR szFullPath[MAX_PATH];

//构造代表子目录和文件夹路径的字符串,使用通配符“*”
lstrcpy(szFilePath, szPath);
lstrcat(szFilePath, "\\*");
//查找第一个文件/目录,获得查找句柄
hListFile = FindFirstFile(szFilePath,&FindFileData);

if(hListFile==INVALID_HANDLE_VALUE)
{
printf("错误:%d",GetLastError());
return 1;
}
else
{
do
{
// 过滤“.”和“..”,不需要遍历
if(lstrcmp(FindFileData.cFileName,TEXT("."))==0||
lstrcmp(FindFileData.cFileName,TEXT(".."))==0)
{
continue;
}
//构造成全路径
wsprintf(szFullPath,"%s\\%s",
szPath,FindFileData.cFileName);
dwTotalFileNum++;
//打印
printf("\n%d\t%s\t",dwTotalFileNum,szFullPath);

//如果是目录,则递归调用,列举下级目录
if(FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
{
printf("

");
ListAllFileInDrectory(szFullPath);
}
}
while(FindNextFile(hListFile, &FindFileData));
}
return 0;
}

/* ************************************
* int main(int argc, PCHAR argv[])
* 功能 调用ListAllFileInDrectory
* 遍历目录下的文件和子目录
*
* 参数 argv[1]为需遍历的路径,如果为空则获取
* 当前路径
*
*
**************************************/
int main(int argc, PCHAR argv[])
{
if(argc == 2)
{
ListAllFileInDrectory(argv[1]);
}
else
{
CHAR szCurrentPath[MAX_PATH];
GetCurrentDirectory(MAX_PATH,szCurrentPath);
ListAllFileInDrectory(szCurrentPath);
}

printf("%d",MAX_PATH);
return 0;
}

vector之迭代器iterator

1、除了用下标访问容器(包括vector)的元素外,标准库还提供了一种方法:使用迭代器(iterator)。

2、迭代器是一种 检查容器内元素并遍历元素的 数据类型。(概念上来理解)

3、标准库为每一种 标准容器(包括vector) 都定义了一种 迭代器类型。
因为迭代器对所有的容器都适用,只有少数容器支持下标操作,所以现在倾向于使用 迭代器 而不是 下标操作 来访问元素,即使对支持下标操作的vector也是一样。

4、迭代器和迭代器类型
容器的iterator类型:每一种容器都定义了自己的 迭代器类型,每个标准库容器都定义了一个名为iterator的成员,这里iterator与迭代器实际类型 (如vector::iterator)的含义相同。

vector::iterator  iter;
定义了一个变量iter,数据类型是 由vector 定义的 iterator类型

注意:iterator表示的含义
1)一般意义上指的是迭代器的概念
2)具体而言时,指的是 由容器定义的具体的 iterator类型,如vector。

重点理解:
1)有很多用做迭代器的类型,这些类型在概念上是相关的。
2)若一种类型支持 一组确定的操作,这些操作可用来 遍历容器内的元素,并访问这些元素的值, 我们就称这种类型为 迭代器。

综合之:各 容器 都定义了自己的 iterator类型 ,用于访问容器内的元素。
也就是每个 容器 都定义了一个名为 iterator 的类型,而这种类型支持 迭代器(概念上的)的各种操作。

5、容器的begin、end操作和 迭代器的操作
vector ivec ;
每种容器都定义了两个函数,begin() end(),用于返回迭代器

vector::iterator iter = ivec.begin()
如果容器ivec内有元素,则begin返回的迭代器指向第一个元素ivec[0]。

由end返回的迭代器 指向容器的 “末端元素的下一个”。
通常称为 超出末端迭代器(off-the-end iterator),表明它指向一个不存在的元素,它只起到一个哨兵的作用,表明已经处理完容器中所有的元素。
如果容器为空,则begin和end返回的迭代器相同。

迭代器类型的自增和解引用运算
自增:++
解引用:*    (其实和C语言中的指针运算差不多)
end()返回的迭代器不指向任何元素,因此不能对其进行自增和解引用操作。
比较操作: ==   !=  (两个迭代器对象指向同一个元素,则他们相等,否则不等)

vector迭代器还支持其他算术操作(其他标准库容器迭代器很少)
iter + n
iter – n
n为整型值,对迭代器对象加上或者减去一个整型值,将产生一个新的迭代器,位置是iter所指元素之前(加)或者之后(减)n个元素的位置。新的迭代器必须指向vector中某个元素,或者是vector末端的后一个元素。

iter1 – iter2 (iter1,iter2必须指向同一vector中元素,或者vector末端之后的下一个元素)
用来计算两个迭代器的距离,该距离是名为different_type的signed类型值,different_type类型和size_type类型相似,也是有vector定义的。

定位vector中间的元素

vector::iterator mid = vi.begin() + vi.size() / 2; 指向vi中最靠近中间的那一个

vector::iterator mid = (vi.begin() + vi.end()) / 2; //会产生什么结果?
vi.begin 和 vi.end() 返回的都是vector迭代器类型,不能进行除法操作。

注意:任何改变vector长度的操作都会使已存在的迭代器失效。
例如,在调用push_back()之后,就不能信赖指向vector的迭代器的值了。

6、const_iterator 和 const iterator对象
每一种容器还定义了一种名为const_iterator的类型,该类型只能用于读取元素,而不能改变元素。
使用const_iterator类型时,我们得到的迭代器所指向的对象不可变,但这个迭代器本身是可以改变。
const_iterator对象可以用于 const vector,也可以是非 const vector,因为它不能改写元素的值。

声明const迭代器时,必须进行初始化,一旦初始化,就不能改变它的值。(可以看出,const迭代器几乎没什么用,它指向的元素可变,但是不能使他指向任何其他元素)。

sort实现vector结构体排序

#include “stdafx.h”

 #include   <vector>  
 #include   <algorithm>
 #include <functional>
  
 using   namespace   std;  

struct AssessTypeInfo
{
unsigned int m_uiType;   //类型ID
 char   m_szName[64];  //类型名称
unsigned int m_uiTotal;   //总分数

};
 bool   lessmark(const   AssessTypeInfo&   s1,const   AssessTypeInfo&   s2)  
 {  
     return   s1.m_uiType   <   s2.m_uiType;  
 }

 bool   greatermark(const   AssessTypeInfo&   s1,const   AssessTypeInfo&   s2)  
 {  
     return   s1.m_uiType   >   s2.m_uiType;  
 }

int   main()  
 {  
  vector<AssessTypeInfo >   ctn   ;  
 
  AssessTypeInfo a1;
  a1.m_uiType=1;

  AssessTypeInfo  a2;
  a2.m_uiType=2;
  AssessTypeInfo  a3;
  a3.m_uiType=3;
  ctn.push_back(a1);
  ctn.push_back(a2);
  ctn.push_back(a3);
  sort(ctn.begin(), ctn.end(),lessmark)   ;   //升序排序
  
  for   ( int  i=0;   i<3;   i++   )  
   printf(“%d\n”,ctn[i].m_uiType);  
 

  sort(ctn.begin(), ctn.end(),greatermark)   ;   //降序排序

 
  return   0  ;  
 }

以上方法就可以实现升序排序,输出结果为 1  2   3 

降序排序结果3  2  1。

c++ vector各种函数介绍及其用法

构造函数
语法:
C++ Vectors可以使用以下任意一种参数方式构造:
vector();    //无参数 – 构造一个空的vector
vector( size_type num, const TYPE &val );   //数量(num)和值(val) – 构造一个初始放入num个值为val的元素的Vector
vector( const vector &from );    //构造一个与vector from 相同的vector
vector( input_iterator start, input_iterator end );    //迭代器(start)和迭代器(end) – 构造一个初始值为[start,end)区间元素的Vector(注:半开区间).
举例:
vector<int> v1( 5, 42 );    //构造了一个包含5个值为42的元素的Vector

find_first_of()和 find_last_of()

string 类提供字符串处理函数,利用这些函数,程序员可以在字符串内查找字符,
提取连续字符序列(称为子串),以及在字符串中删除和添加。我们将介绍一些主要函数。

1.函数find_first_of()和 find_last_of() 执行简单的模式匹配,如在字符串中查找单个字符c。
函数find_first_of() 查找在字符串中第1个出现的字符c,而函数find_last_of()查找最后
一个出现的c。匹配的位置是返回值。如果没有匹配发生,则函数返回-1.

int find_first_of(char c, int start = 0):
查找字符串中第1个出现的c,由位置start开始。
如果有匹配,则返回匹配位置;否则,返回-1.默认情况下,start为0,函数搜索
整个字符串。

int find_last_of(char c):
查找字符串中最后一个出现的c。有匹配,则返回匹配位置;否则返回-1.
该搜索在字符末尾查找匹配,所以没有提供起始位置。
继续阅读

fopen与fopen_s的区别

在定义FILE * fp 之后,fopen的用法是:fp = fopen(filename,”w”)。而对于fopen_s来说,还得定义另外一个变量errno_t err,然后err = fopen_s(fp,filename,”w”)。返回值的话,对于fopen来说,打开文件成功的话返回文件指针(赋值给fp),打开失败则返回NULL值;对于fopen_s来说,打开文件成功返回0,失败返回非0。

c++文件系统(三)

五、文件和目录管理

4.获取程序所在的目录、程序模块路径,获取和设置当前目录
/* ****************************************************************************
 * cur_mod_dir.c 获取当前是目录、获取程序所在目录,获取模块路径
 * ***************************************************************************/
#include <Windows.h>
#include <stdio.h>
/* *********************************************************************
 * int main(void)
 * 功能:演示使用设置获取当前路径
 *          演示获取模块路径
 * ********************************************************************/

c++文件系统(二)

四、磁盘和驱动器管理

1.判断光驱中是否有光盘

/* *****************************************************************
* cdrom.c 判断光驱中是否有光盘
* ****************************************************************/
/*头文件*/
#include <Windows.h>
#include <stdio.h>
#include <tchar.h>
/*预定义*/
#define BUFSIZE 512
/* ***************************************************************
* int main(int argc,PCHAR argv[])
* 功能:应用程序主函数,根据输入的驱动器
*           根路径参数判断是否为光驱,是否放入光盘
* 参数:驱动器根路径,比如“D:\”
* **************************************************************/
int main(int argc,PCHAR argv[])
{
//存储文件系统类别名
CHAR szFileSystemNameBuffer[BUFSIZE];
DWORD dwLastError;
DWORD dwSystemFlags;
//判断输入运行时参数
if (argc != 2)
{
printf(“请输入驱动器的根路径,比如:\”D:\\\”\n”);
return -1;
}
//判断驱动器是否是否为CD\DVD ROM
if (GetDriveType(argv[1]) != DRIVE_CDROM)
{
printf(“驱动器%s不是CD/DVD ROM.\n”,argv[1]);
return -1;
}
//获取卷信息
if (!GetVolumeInformation(
argv[1],NULL,0,
NULL,NULL,
&dwSystemFlags,
szFileSystemNameBuffer,
BUFSIZE
))
{
dwLastError = GetLastError();
if (dwLastError == 21)
{
printf(“设备未就绪,请放入光盘!\n”);
return 0;
}
else
{
printf(“GetVolumeInfomation 错误 %d\n”,dwLastError);
}
}
printf(“光盘已经放入,文件系统类别%s.\n”,szFileSystemNameBuffer);
return 0;
}
2.获取磁盘分区的总容量、空闲容量、簇、扇区信息