C++语法高手进

Posted 2023-05-09

我是学网络建设的,今年还不到20 我想学C++ 请大虾帮忙谢谢 我就是想要C语言的基本语法 别给我发超连接,因为我是在服务器上浏览的.怕中病毒, 不成心回答干脆别回答,刚刚发的问题有人嫌少,只要回答的好,我再追...
谢谢大家
大家答的都很好

C 基本语法(上)
0. 编译C 程序时，编译器自动定义了一个预处理名字__cplusplus，而编译标准C时，自动定义名字__STDC__。另外几个比较有用的预定义名字是__LINE__(文件的当前编译行数)，__FILE__(当前被编译的文件名字)，__DATE__(编译日期)和__TIME__(编译时间)。

1. C库头文件的C 名字总是以字母C开头，后面去掉后缀.h的C名字，如在C 库中的名字是。两种使用方法：
#include 或者
#include
using namespace std;

2. 静态与动态内存分配的两个主要区别：(1)静态对象是有名字的变量，可以直接进行操作，动态对象是没有名字的变量，可以通过指针间接进行操作；(2)静态对象的分配和释放由编译器自动处理，而动态对象必须由程序员显式的管理，通过new和delete两个表达式来完成。

3. 类的缺省构造函数是不需要用户提供任何参数的构造函数。

4. STL中标准数组-vector(文件)，两种遍历方式：(1)通过下标操作符；(2)使用迭代器，如vector<int>::iterator iter;可以通过对iterator解引用来直接访问实际的元素*iter;STL提供了作用于容器类型的泛型算法，头文件。

5. 文字常量是不可寻址的。

6. 常用的几个转义序列：
newline(换行符) \n \14
horizontal tab(水平制表符) \t
vertical tab(垂直制表符) \v
backspace(退格符) \b
carriage return(回车键) \r
formfeed(进纸键) \f
alert (bell)(响铃符) \a \7

7. 变量和文字常量都有存储区，区别在于变量是可寻址的，对于每个变量，都有两个值与之关联：数据值，称为对象的右值，是被读取的值，文字常量和变量都可以用作右值；地址值，被称为变量的左值，是位置值，文字变量不用被用作左值。

8. 每个指针都有一个相关的类型。不同数据类型的指针之间的区别在于指针所指的对象的类型上。如果我们需要的仅仅是持有地址值，C 提供了一种特殊的指针类型：空(void *)类型指针，它可以被任何数据指针类型的地址值赋值，除了函数指针。不能操作空类型指针所指向的对象，只能传送该地址值或将它与其他地址值做比较。

9. C风格的算法循环：
while(*p )…

10. 正确定义引用，如下：
const int ival = 1024;
const int *&pi_ref = &ival; // 错误，pi_ref是一个引用，它指向定义为const的int型对象的一个指针，引用不是指向常量，而是指向了一个非常量指针
const int *const &pi_ref = &ival; // OK

11. 指针和引用有两个主要区别，引用必须总是指向一个变量；如果一个引用给另外一个引用赋值，那么改变的是被引用对象而不是引用本身。

12. 布尔类型对象虽然也被看作整数类型的对象，但是它不能被声明为signed，unsigned，short或long。

13. 一个数组不能被另外一个数组初始化，也不能被赋值给另外一个数组，而且，C 不容许声明一个引用数组。

14. 数组标志符代表数组中的第一个元素的地址。它的类型是数组元素类型的指针。
int ia[10];
第一个元素的地址: ia或者是&ia[0]
第二个元素的地址: ia 1或者是&ia[1]

15. STL中vector有两种不同的使用形式：数组习惯，即使用下标操作符，注意只能操作已经存在的成员；STL习惯，使用iterator来操作，对其解引用可以访问实际的对象，也可以通过加减来移动位置。雷同与5。

16. typedef用来为内置的或用户定义的数据类型引入助记符号。
typedef char *cstring;
extern const cstring cstr;
其中cstr的类型是 char *const cstr;

17. 当一个对象的值可能会在编译器的控制或监制之外被改变时，那么该变量应该声明为volatile，编译器执行的某些例行优化不能应用在已经指定为volatile的对象上。

18. pair类可以在单个对象内部把相同类型或不同类型的两个值关联起来。我们可以使用成员访问符号来访问pair中的单个元素，他们的名字为first和second。

19. 在类体外定义的内联成员函数，应该被包含在含有该类定义的头文件中。

20. setw()是一个预定义的iostream操作符，它读入的字符数最多为传递给它的参数减一。如setw(1024)，则最多读入1023个字符。

21. 标准C 头文件提供了与内置类型表示有关的信息，另外，还有标准C头文件和。

22. 对于二元操作符<或者>，左右操作数的计算顺序在标准C和C 中是都是未定义的，因此计算过程必须是与顺序无关的。如ia[index ]就是未定义的。

23. 初始化过程为对象提供初值，而赋值是用一个新值覆盖对象的当前值，一个对象只能被初始化一次，也就是在它被定义的时候，而赋值可以多次。如初始化int ival = 1024;赋值 ival = 1025;赋值操作符的左操作数必须是左值。

24. sizeof操作符的作用是返回一个对象或者类型名的字节长度，返回值类型是size_t，这是一种与机器有关的typedef定义，可以在文件中找到它的定义。

25. 按位非操作符(~)翻转操作数的每一位。移位操作符(<<和>>)将其左边操作数的位向左或者向右移动某些位，移到外面的位被丢弃，左移操作符从右边开始用0填充空位。右移操作符，如果是无符号数从左边开始插入0，否则它或者插入符号位的拷贝或者插入0，这由具体实现定义。按位与(&)对两个操作数的每一位进行与操作(只有两位同时为1时值才为1)。按位异或(^)操作符对两个操作数的每一位进行异或操作(只有两个含有一个1时值才为1，即两位不同值为1)。按位或(|)操作符对两个操作数的每一为进行或操作(只有两位同时为0时值才为0)。如将整数a的第27位设为1：a |= 1 << 27；将第27为设为0：a &= ~(1 << 27) ；测试第27位是否为1：a & (1 << 27)。

26. bitset类，头文件为，支持三种构造方式，第一是直接指定向量长度，如bitset <32> bs;第二是显式提供一个无符号参数，如bitset<32> bs(012);将第1和第3位设置为1。第三是传递一个代表1和0集合的字符串参数，还可以标记字符串的范围，如string bitval(“1111110101100011010101”);bitset<32> bs(bitval, 6, 4);则bs的第1和第5位被初始化为1；如果去掉指定字符串范围的第三个参数，则范围是指定的位置开始一直到字符串的末尾。而函数to_string和to_ulong则把bitset对象转换为字符串和整型表示。

27. 操作符优先级表

28. 隐式转换发生在下列情况下：1.混合类型的算术表达式，即算术转换；2.用一种类型的表达式赋值给另一种类型的对象；3.把一个表达式传递给一个函数调用，表达式的类型和形式参数的类型不相同；4.从一个函数返回一个表达式。

29. 算术转换的两个原则：1.如果必要的话，类型总是提升为较宽的类型；2.所有含有小于整型的整值类型的算术表达式，在计算之前，其类型都会被转换为整型。

30. const_cast转换掉表达式的常量性以及volatile对象的volatile性；如const_cast<char *>ptr；编译器隐式执行的任何类型转换都可以由static_cast显式完成。reinterpret_cast通常对操作数的位模式执行一个比较低层次的重新解释。dynamic_cast支持在运行时刻识别由指针或引用指向的类对象。

31. typename是标准C 中新引入的关键字，用于template中。

32. 两个主要的顺序容器是list和vector，另外一个顺序容器是deque；两个主要的关联容器是map和set。

33. 选择顺序容器类型的一些准则：(1)随机访问，vector比list好得多；(2)已知道元素的个数，则vector比list强；(3)如果不只是在容器两端插入和删除元素，则list比vector强很多；(4)除非需要在容器首部插入和删除元素，则vector比deque好。对于小的数据类型，vector的插入大批量数据的性能比list好很多，而大型数据时则相反，解决方案是只保留大型数据的指针。Reserve函数容许将容器的容量设置成一个显式指定的值，resize函数重新设置容器的长度；每个容器支持一组关系操作符；用户定义的类类型必须支持等于操作符，必须支持小于操作符，元素类型必须支持一个缺省值（对类类型，指缺省构造函数）。

34. 除了iterator类型，每个容器还定义了一个const_iterator类型，对遍历const容器是必需的，const_iterator容许以只读方式访问容器的底层元素。Iterator算术运算(是指加法或者减法等算术运算，而不是重载的 操作符)只适用vector或deque，而不适用于list因为list在内存中不是连续存储的。

35. string类的find函数返回一个索引类型string::size_type或者返回string::npos；find_first_of提供了被搜索字符串中任意一个字符相匹配的第一次出现，并返回它的索引位置，substr函数生成现有string对象的子串的一个拷贝，第一个参数指明开始的位置，第二个可选的参数指明子串的长度。rfind，查找最后的指定子串的出现；find_first_not_of查找第一个不与要搜索字符串的任意字符相匹配的字符；find_last_of查找与搜索字符串任意元素相匹配的最后一个字符；find_last_not_of查找字符串中的与搜索字符串任意字符全不匹配的最后一个字符。

36. tolower函数接受一个大写字符，并返回与之等价的小写字母，必须包含头文件，另外一些该文件中的函数，isalpha, isdigit, ispunct, isspace, toupper等。

37. assign对把字符串进行赋值；append则类似于 =操作符；swap交换两个string的值；进行越界检查的at类似于[]操作符；compare函数提供了两个字符串的字典序比较；replace函数提供了十种方式，可以用一个或者多个字符替换字符串中的一个或多个现有的字符。

38. map定义了一个类型value_type，表示相关的键值对，用于insert函数。

39. 关联容器支持以下两个函数：find查找指定key，不存在则返回end()；count返回指定key值的出现的次数。

40. set定义了一个类型difference_type，是两个iterator相减的结果类型；inserter类用来执行插入操作。如:copy(in, eos, inserter(set1, set1.begin());因为copy执行的是赋值操作，所以使用inserter使用插入操作取代赋值操作。

41. multiset和multimap的特殊操作equal_range返回iterator对值，如:pair pos; pos = mp.equal_range(tst);

42. stack类，头文件，函数top和pop分别是访问栈顶元素和删除栈顶元素。栈类型是容器适配器，因为它把栈抽象施加到底层容器上，缺省情况下栈使用deque实现，可以自定义缺省的底层容器，如使用list构建stack：stack<int, list<int> > intStack;

43. C 中，数组永远不会按值传递，它总是传递第一个元素(准确的说是第0个)的指针。多维数组被传递为指向第0个元素的指针。如matrix[][10]等同于int (*matrix)[10]，都表示matrix是个二维数组，每行10列。而int *matrix[10]表示一个含有10指向int的指针的数组。

44. UNIX系统函数chmod改变文件的保护级别，它的函数声明在系统头文件中。

45. 链接指示符的第一种形式由关键字extern后跟一个字符串常量以及一个普通的函数声明构成，如extern “C” void exit();第二种形式是是多个函数声明用大括号包含再链接指示符复合语句中。链接指示符不能出现在函数中，而且放在头文件中更合适。

46. 支持命令行格式的主函数:int main(int argc, char *argv[]);

47. 指向函数的指针，如int (*pFunc)(int, int)；将取地址符作用于函数名上也能产生指向该类型的指针。如已经存在函数定义int f1(int); int (*pf1)(int)=f1; int (*pf2)(int)=&f1;函数调用可以使用pf1(1)格式或者(*pf1)(1)格式。当一个函数名没有被调用操作符修饰时，会被解释为该类型函数的指针，如存在函数定义int f(int)；表达式f被解释为int (*)(int)。

48. 函数指针数组的定义:int (*testCases[10])();使用typedef可以使声明更易读。如typedef int (*PFV)(); PFV testCases[10];声明一个“指向函数指针数组的指针”，如PFV (*pArray)[10];调用其中函数(*pArray)[2]();

49. 函数参数的类型不能是函数类型，函数类型的参数将被自动转换为该函数类型的指针。如存在函数类型typedef int funtype(int);void sort(int, funtype);与函数定义sort(int, int(*)(int));等价。函数指针也可以作为函数返回值的类型，如int (*ff(int))(int *, int);该声明将ff声明一个函数，它有一个int的参数，它的返回值为一个指向函数的指针，类型为int (*)(int *,int)；

50. 指向C函数的指针与指向C 的函数指针类型不同，也就是：int (*fcpp)(int)与extern “C” int (*fpc)(int)类型不同。并且，当链接指示符作用一个声明上时，所有被它声明的函数都受影响，如extern “C” void f1(void (*pfParm)(int));其中pfParm也是C函数指针。因此，要实现一个含有C函数指针作为参数的C 函数，可以使用typedef，如extern “C” typedef void FC(int); C 函数 void f2(FC *pfParam);

51. 关键字extern为声明但不定义提供了一种方法，extern声明不会引起内存被分配。

52. 设计头文件时不应该含有非inline函数和对象的定义。符号常量的定义和inline函数可以被重复定义多次，在编译期间，在可能的情况下，符号常量的值会取代该名字的出现，这个过程为常量折叠。符号常量是任何const类型的对象。但是如下定义不符合 char *const buf = new char[10];因为它的值不能在编译时确定，不能定义在头文件；const char *msg =”Error”;因为msg不是常量，它是指向常量值的非常量指针，必须修改为const char *const msg=””;

53. 有三种局部对象：自动对象，寄存器对象和局部静态对象。在函数中频繁使用的变量可以使用关键字register声明为寄存器对象。

54. delete表达式只能作用于由new表达式从空闲存储区分配的指针上，如果作用于其他内存指针上，可能导致问题，但是作用于值为0的指针上，delete不会指向任何操作。

55. auto_ptr是STL提供的类模板，可以帮助程序员自动管理用new表达式动态分配的单个对象。头文件为，只有拥有底层对象所有权的对象负责释放内存，但使用Copy constructor和Assignment进行操作时，左边的对象得到所有权，而右边的则被撤销所有权。使用get来测试是否指向一个底层对象，使用reset来重新设置一个底层对象，assignment操作符不支持内存指针。

56. 可以创建动态的const对象，如const int *pci = new const int(1024);不能创建const对象数组，创建的const对象必须初始化。

57. 定位new表达式容许程序员要求将对象创建在已经被分配好的内存中。如：char *buf=new char [1024];Foo *pb = new (buf) Foo;

58. 可以使用未命名的namespace来声明一个局部于某一文件的实体，即该函数只在当前文件中可见。通常在实现文件中使用，这种方法是用来替换C语言中的static函数声明。

59. 重载函数，两个函数的函数名相同，但函数参数表必须不同，参数个数或参数类型不同；识别函数声明并不考虑传值参数类型是const或者volatile，即void f(int)和函数void f(const int)是同一个函数。但是如果是传地址或者传引用时，则需要考虑这两个修饰符。void f(int *)和函数void f(const int *)为不同的函数。

60. 重载函数集合中的所有函数都应该在同一个域中声明。using声明和using指示符可以使得一个名字空间的成员在另外一个名字空间可见，这对重载函数集合产生影响。using声明总是为重载函数的所有函数声明别名，如果引入一个函数在该域中已经存在并且参数表相同，则产生错误。而extern “C”链接指示符只能指定重载函数集中的一个函数。

61. 函数重载解析的三个步骤(1)确定函数调用考虑的重载函数的集合，确定函数调用中实参表的属性；(2)从重载函数集合中选择函数，该函数可以在给定的情况下用实参进行调用；(3)选择与调用最匹配的函数。在第二步中，编译器确定需要进行的参数转换，并划分等级，通常分为精确匹配；与一个类型转换匹配；无匹配。其中类型转换通常分为三组：提升、标准转换和用户定义的转换。

62. 精确匹配细节：即使一个实参必须应用一些最小的类型转换才能将其转换为相应函数参数的类型；这些最小的类型转换包括：左值到右值的转换；从数组到指针；从函数到指针的转换和限定类型转换(通常是const和volatile类型转换)。精确匹配可以使用一个显式强制转换强行执行，这时实参类型就为转换后的类型。

C 基本语法(下)

0. 类型转换中的提示实际上就是内置数据类型的提升，如char转换为int，bool转换为int，float转换为double等。

1. 类型转换中的标准转换有五种类型：(1)整值类型转换(不包括提升)；(2)浮点转换；(3)浮点-整值转换；(4)指针转换和(5)bool转换。前三种转换是有潜在危险的转换。所有的标准转换都是等价的。一些注意点：0可以被转换为任何指针类型，这样创建的指针称为空指针值，同时0也可以是任何整型常量表达式。常量表达式0L及0x00都属于整值类型因此能够被转换为int *的空指针值。指针转换允许任何指针类型的实参转换成void *，但是函数指针不能用标准转换为void *。

2. 对于引用参数来说，如果实参是该引用的有效初始值，则为精确匹配，否则为不匹配。

3. 模板非类型参数代表了一个常量表达式，由一个普通的参数声明构成，表示该参数名代表了模板定义种的一个常量。在实例化时，该常量会被一个编译时已知的常量值代替。

4. 在模板中，为了支持类型表达式，必须使用typename；如typename Param::name *p;定义了一个指针p；如果不使用typename则该表达式为乘法。另外，模板函数也可以被声明为inline或extern，必须把指示符放在参数模板后。如template <typename T> inline T fun1()…

5. 函数实参的推演中三种类型转换是允许的：(1)左值转换；(2)限定转换(const和volatile指示符)；(3)到一个基类的转换：如果实参是一个类，它有一个从被指定为函数参数的类模板实例化而来的基类；如下面的代码：template <typename T> class Array ; template <typename T> T min(Array &array) …；

6. 可以使用显式指定模板参数，模板参数被显式指定在逗号分隔的列表中，紧跟在函数模板实例的名字后面；如min<unsigned int>(a, b);代码强行指定模板参数以unsigned int转换。模板显式指定参数类似于默认参数，只能省略后面的参数。

7. C 支持两种模板编译模式：包含模式和分离模式。包含模式下，在每个模板被实例化的文件中包含函数模板的定义，并且往往把定义放在头文件中；分离模式下，函数模板的声明被放在头文件中，它的定义放在另外一个实现文件中，函数模板在实现文件中的定义必须使用关键字export。

8. C 支持模板的显式实例化，在显式实例化声明所在的文件中，函数模板的定义必须被给出。如template <typename T> T f(T t); 显式实例化为int *类型，template int *f(int *);

9. C 支持模板的显式特化定义，如：template <typename T> T max(T t1, T t2)…显式特化const char *类型的定义：template <> const char *max<const char *>(const char *c1, const char *c2);显式特化隐藏了通用模板对于该类型的实例。如果模板实参可以从函数参数中推演出来，则模板实参的显式特化可以从其中取消。如上面的例子: template <> const char *max(const char *, const char *);其省略与显式指定模板参数一样。

10. 抛出异常可通过throw表达式来实现。如抛出一个popOnEmpty(类对象)的异常，表达式为throw popOnEmpty();同时在catch子句中，为了防止大型类对象的复制，可以将catch子句的异常声明改为引用。

11. 在查找用来处理被抛出异常的catch子句时，因为异常而退出复合语句和函数定义，这个过程称为栈展开。C 保证，随着栈的展开，尽管局部类对象的生命期是因为抛出异常而结束，但是所有的析构函数将被调用。要重新抛出接受到的异常，使用语句throw;重新抛出的过程中希望对接受到的异常对象进行修改，必须将catch子句的异常声明改为引用。

12. 异常规范跟随在函数参数表之后，用throw指定，后面是异常类型表。如void pop(int &value) throw(popOnEmpty);异常规范保证不会抛出任何没有出现在异常类型表中的异常。如果在运行时抛出一个没有出现在异常类型表中的异常，则系统调用C 标准库中定义的函数unexpected，该函数直接调用了terminate函数结束程序。空的异常规范不会抛出任何异常。

13. 异常规范可以在函数声明中指出，当有异常规范的指针被初始化时，被用作右值的指针异常规范必须比用作左值的指针规范一样或者更严格，当然，参数类型表必须相同。

14. 使用函数指针来使得template适应更多的场合。内置的函数指针声明的模板定义，代码如下: template< typename Type, bool (*Comp)(const Type&, const Type &)> const Type& min(const Type *p, Comp comp)；该方案的主要缺点是函数调用使它无法内联。使用函数对象来替代函数指针，函数对象是类实现，它重载了调用操作符，即operaotr ()函数。有两个优点：(1)如果被重载的调用操作符是inline，则编译器能执行内联编译；(2)函数对象可以拥有任意数目的额外数据来缓冲结果。改写模板使之能同时接受函数指针和函数对象(缺点是没有任何的原型检查)，template<typename Type, typename Comp> min(const Type *p, Comp comp); 参考技术A Visual C++ .NET技术内幕（第6版）
http://book.jqcq.com/product/393359.html

本书特色： ·既有原理性的说明，也有指导性的介绍，还有很好的例子来帮助理解一些技术细节。 ·在讲解的时候语言简洁不啰嗦 ·作者对于前面部分的传统内容有所精简，以便为后面的内容腾出空间。本书新增内容(主要是与第四版相比较) ·本书的前三部分内容主?...

Visual C++6.0入门与提高
http://book.jqcq.com/product/384528.html

本书全面讲解了Visual C++ 6.0应用程序开发方面的内容，包括集成开发环境IDE、C++语言的基本语法和面向对象技术、微软基础类库（MFC）、MFC应用程序框架、AppWizard和ClassWizard的使用方法、各种对话框的使用方法、常用窗体控件和高级控件的详细用途及其使用方法、 ...

Visual C++6.0 程序设计从入门到精通（附CD-ROM光盘一张）
http://book.jqcq.com/product/430749.html

本书首先从Visual C++6.0的基础知识入手，详细介绍了Visual C++6.0的操作环境和应用程序的基本框架，然后按照由易到难、由浅入深地顺序介绍了用Visual C++6.0开发Windows程序的方法，包括菜单和加速键、对话框、常用控件、文本和字体类、图形图像、文件操作、多线程 ...本回答被提问者采纳 参考技术B 你去外边书店买一本谭浩强的《C++程序设计》吧，一般书店都有卖的，我觉得初学C++最好的就是看这本书，虽然还是有一些厚，但是写的很容易懂，所以会看的比较快。再说纸质书怎么都比电子书看着舒服的。 参考技术C 买本《c++》 潭浩强 编写 后面的附录有关于语法的内容。
实在不行就搜一下 "C++ 完全手册". 参考技术D 搂主~百易老板~的答案已经很全面了，我没有什么补充的，只是希望你学好c++在年轻的生命中有所作为……相信自己一定会成功！+U+U^^

VC++高手进！！！！！！

请用VC++编程！操作系统的银行家问题，读者——写者问题！
我说的是VC++，不是C语言啊！！！
两个算法都要！！！要原代码，最好是自己写的，不要到网上下，并表明注释！
或者发到我的邮箱好了:[e-mail]
谢谢~~

楼主啊。既然有现成的算法为什么要自己写一遍啊。写一遍程序真的很麻烦+无聊啊，我找的已经是有介绍注释和源代码的版本啊。稍微看看就能看懂拉
C++也兼容C语言的，所以如果没有必要用class的话没有什么大的区别。

C++下的银行家问题：

一．算法介绍:
**数据结构:
1.可利用资源向量Available
2.最大需求矩阵Max
3.分配矩阵Allocation
4.需求矩阵Need
**功能介绍:
模拟实现Dijkstra的银行家算法以避免死锁的出现.分两部分组成:
第一部分:银行家算法(扫描)
1．如果Request<=Need,则转向2;否则,出错
2．如果Request<=Available,则转向3,否则等待
3．系统试探分配请求的资源给进程
4．系统执行安全性算法
第二部分:安全性算法
1.设置两个向量
(1).工作向量:Work=Available(表示系统可提供给进程继续运行所需要的各类资源数目)
(2).Finish:表示系统是否有足够资源分配给进程(True:有;False:没有).初始化为False
2.若Finish[i]=False&&Need<=Work,则执行3;否则执行4(I为资源类别)
3.进程P获得第i类资源,则顺利执行直至完成!并释放资源:
Work=Work+Allocation;
Finish[i]=true;
转2
4. 若所有进程的Finish[i]=true,则表示系统安全;否则,不安全!

二.原代码及注释:
#include<iostream.h>
#include<fstream.h>
#include<stdlib.h>
#include "windows.h"
#define MAX_PROCESS 32 //最大进程数
#define MAX_COURCE 64 //最大资源类别

int MAX_FACT_PROCESS; //实际总进程数
int MAX_FACT_COURCE; //实际资源类别数
int Available[MAX_COURCE]; //可利用资源向量
int Max[MAX_PROCESS][MAX_COURCE]; //最大需求矩阵
int Allocation[MAX_PROCESS][MAX_COURCE]; //分配矩阵
int Need[MAX_PROCESS][MAX_COURCE]; //需求矩阵

int Request_PROCESS; //发出请求的进程
int Request_COURCE; //被请求资源类别
int Request_COURCE_NEMBER; //请求资源数

struct COMP
int value;
int num;
int next;
;
int flag=0;
void Read_Initiate(void) //读入初始化文档
ifstream infile("Initiate.txt");
if(!infile)
cout<<"不能打开输入文件:"<<"Initiate.txt"<<\'\\n\';
exit(1);

cout<<"开始读入初始化文档"<<\'\\n\';
int ch;
int Array[MAX_PROCESS*MAX_COURCE*2];
int num=0;
while(infile>>ch)
Array[num++]=ch;
num=0;
MAX_FACT_COURCE=Array[num++];
for(int j=0;j<MAX_FACT_COURCE;j++)
Available[j]=Array[num++];
MAX_FACT_PROCESS=Array[num++];
for(int i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
Max[i][j]=Array[num++];

infile.close();


void Write_Initiate(void) //写入初始化文档(分配资源
ofstream outfile("Initiate.txt");
if(!outfile)
cout<<"不能打开初始化文档："<<\'\\n\';
exit(1);

int Array[MAX_PROCESS*MAX_COURCE*2];
int num=0;
Array[num++]=MAX_FACT_COURCE;
for(int i=0;i<MAX_FACT_COURCE;i++)
Array[num++]=Available[i];
Array[num++]=MAX_FACT_PROCESS;
for(i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
Array[num++]=Max[i][j];

num=0;
outfile<<Array[num++]<<" ";
for(i=0;i<MAX_FACT_COURCE;i++)
outfile<<Array[num++]<<" ";
outfile<<\'\\n\'<<Array[num++]<<endl;
for(i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
outfile<<Array[num++]<<" ";
outfile<<endl;

DWORD m_delay=3000;
Sleep(m_delay);
outfile.close();
cout<<"修改初始化文档成功!"<<endl;


void Allocated_list(void) //读入已分配资源列表
ifstream infile("Allocated_list.txt");
if(!infile)
cout<<"不能打开输入文件:"<<"Allocated_list.txt"<<\'\\n\';
exit(1);

cout<<"开始读入已分配资源列表"<<\'\\n\';
int ch,num=0;
int Array[MAX_PROCESS*MAX_COURCE];
while(infile>>ch)
Array[num++]=ch;
num=0;
for(int i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
Allocation[i][j]=Array[num++];
infile.close();


void Set_Need(void) //设置需求矩阵
cout<<"设置需求矩阵"<<\'\\n\';
for(int i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
Need[i][j]=Max[i][j]-Allocation[i][j];


void Read_Request(void) //读入请求向量
ifstream infile("Request_list.txt");
if(!infile)
cout<<"不能打开输入文件:"<<"Request_list.txt"<<\'\\n\';
exit(1);

cout<<"开始读入请求向量"<<\'\\n\';
int Array[3];
int num=0,ch;
while(infile>>ch)
Array[num++]=ch;
Request_PROCESS=Array[0];
Request_COURCE=Array[1];
Request_COURCE_NEMBER=Array[2];
infile.close();


void Write_Allocation(void) //修改资源分配列表(资源分配)
ofstream outfile("Allocated_list.txt");
if(!outfile)
cout<<"不能打开资源分配列表："<<\'\\n\';
exit(1);

for(int i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
outfile<<Allocation[i][j]<<" ";
outfile<<endl;

DWORD m_delay=3000;
Sleep(m_delay);
cout<<"修改资源分配列表成功!"<<endl;
outfile.close();


void Allocate_Source(void) //开始分配(已通过扫描和安全性检测)
cout<<\'\\n\'<<"开始给第"<<Request_PROCESS<<"个进程分配第"<<Request_COURCE
<<"类资源"<<Request_COURCE_NEMBER<<"个"<<endl;
Write_Initiate();
Write_Allocation();
DWORD m_delay=3000;
Sleep(m_delay);
cout<<\'\\n\'<<"祝贺您，资源分配已成功!"<<endl;


void Test_Safty() //安全性检测
cout<<\'\\n\'<<"进入安全性检测!"<<endl;
int Work[MAX_COURCE];
for(int i=0;i<MAX_FACT_COURCE;i++)
Work[i]=Available[i];

bool Finish[MAX_PROCESS][MAX_COURCE];
for(i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
Finish[i][j]=false;
COMP Array[32];
for(i=0;i<MAX_FACT_PROCESS;i++)

Array[i].value=Need[i][Request_COURCE-1];
Array[i].num=i;

for(i=0;i<MAX_FACT_PROCESS;i++)
for(int j=i+1;j<MAX_FACT_PROCESS;j++)
if(Array[i].value>=Array[j].value)
int t;
t=Array[j].value;
Array[j].value=Array[i].value;
Array[i].value=t;
t=Array[j].num;
Array[j].num=Array[i].num;
Array[i].num=t;

else continue;

DWORD m_delay=3000;
Sleep(m_delay);
/*for(i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
cout<<Need[i][j]<<\'\\t\';
cout<<endl;

*/
if(Finish[Request_PROCESS-1][Request_COURCE-1]==false&&Need[Request_PROCESS-1][Request_COURCE-1]<=Work[Request_COURCE-1])

Work[Request_COURCE-1]=Work[Request_COURCE-1]+Allocation[Request_PROCESS-1][Request_COURCE-1];
Finish[Request_PROCESS-1][Request_COURCE-1]=true;

else

cout<<"未通过安全性测试，不与以分配"<<endl;
exit(0);

for(i=0;i<MAX_FACT_PROCESS;i++)
if(Array[i].num==Request_PROCESS-1)
continue;
if(Array[i].num!=Request_PROCESS-1&&Finish[Array[i].num][Request_COURCE-1]==false&&Need[Array[i].num][Request_COURCE-1]<=Work[Request_COURCE-1])
Work[Request_COURCE-1]=Work[Request_COURCE-1]+Allocation[Array[i].num][Request_COURCE-1];
Finish[Array[i].num][Request_COURCE-1]=true;


for(i=0;i<MAX_FACT_PROCESS;i++)

if(Finish[i][Request_COURCE-1]==true)
continue;
else

cout<<"未通过安全性测试，不与以分配"<<endl;
exit(0);


cout<<\'\\n\'<<"找到一个安全序列:"<<"P"<<Request_PROCESS<<"--->";
for(i=0;i<MAX_FACT_PROCESS;i++)
if(Array[i].num==Request_PROCESS)
continue;
else
cout<<"P"<<Array[i].num<<"--->";

cout<<\'\\n\'<<"已通过安全性测试!"<<endl;
Allocate_Source();


void RUN(void) //执行银行家算法

cout<<"*************************************************"<<\'\\n\'<<"点击1执行!"
<<\'\\n\'<<"点击2退出!"
<<\'\\n\'<<"*************************************************"<<endl;
cin>>flag;
if(flag==2)
exit(0);
if(flag==1)

cout<<"开始扫描请求信息!"<<endl;
DWORD m_delay=3000;
Sleep(m_delay);
if(Request_COURCE_NEMBER>Need[Request_PROCESS-1][Request_COURCE-1])

cout<<\'\\n\'<<"第"<<Request_PROCESS<<"个进程请求第"<<Request_COURCE<<"类资源"<<Request_COURCE_NEMBER<<"个"<<endl;
cout<<"可是已超出该进程尚需的该类资源的最大数量,所以不予以分配!!"<<endl;
exit(0);

if(Request_COURCE_NEMBER>Available[Request_COURCE-1])

cout<<\'\\n\'<<"第"<<Request_PROCESS<<"个进程请求第"<<Request_COURCE<<"类资源"<<Request_COURCE_NEMBER<<"个"<<endl;
cout<<"可是系统中尚无足够的资源,所以进入等待队列!!"<<endl;
exit(0);

else
Available[Request_COURCE-1]=Available[Request_COURCE-1]-Request_COURCE_NEMBER;
Allocation[Request_PROCESS-1][Request_COURCE-1]=Allocation[Request_PROCESS-1][Request_COURCE-1]+Request_COURCE_NEMBER;
Need[Request_PROCESS-1][Request_COURCE-1]=Need[Request_PROCESS-1][Request_COURCE-1]-Request_COURCE_NEMBER;
cout<<"扫描通过"<<endl;
Sleep(m_delay);
Test_Safty();


else
cout<<"输入错误,请重新输入!"<<\'\\n\';
RUN();



void main(void)
Read_Initiate();
cout<<MAX_FACT_COURCE<<\'\\t\';
for(int i=0;i<MAX_FACT_COURCE;i++)
cout<<Available[i]<<\'\\t\';
cout<<endl<<MAX_FACT_PROCESS<<endl;
for(i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
cout<<Max[i][j]<<\'\\t\';
cout<<endl;

DWORD m_delay=3000;
Sleep(m_delay);
cout<<"读入成功"<<\'\\n\';

Allocated_list();
for(i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
cout<<Allocation[i][j]<<\'\\t\';
cout<<endl;

Sleep(m_delay);
cout<<"读入成功"<<\'\\n\';

Set_Need();
for(i=0;i<MAX_FACT_PROCESS;i++)
for(int j=0;j<MAX_FACT_COURCE;j++)
cout<<Need[i][j]<<\'\\t\';
cout<<endl;

Sleep(m_delay);
cout<<"设置成功"<<\'\\n\';

Read_Request();
cout<<\'\\n\'<<"第"<<Request_PROCESS<<"个进程请求第"<<Request_COURCE<<"类资源"<<Request_COURCE_NEMBER<<"个"<<endl;
cout<<\'\\n\'<<"读入成功"<<\'\\n\';

RUN();


三．数据测试
注:数组Array[I]表示第I+1个实际意义量
需要创建三个txt文本。
1.Initiate.txt文本
3 3 3 2 //共有3类资源,Available[0]=3; Available[1]=3; Available[2]=2
5 //当前系统中有个进程
7 5 3 // Max[0][0]=7
3 2 2 //Max[1][1]=3
9 0 2
2 2 2
4 3 3
2.Allocated_list.txt文本
0 1 0 //Allocation[0][1]=1
2 0 0
3 0 2
2 1 1
0 0 2
3.Request_list.txt文本
2 1 1 //第2个进程请求第1类资源1个Request[1][0]=1
四．程序说明:
本程序假设当前时刻只有一个进程请求某一类资源n个.
若要满足某个进程当前时刻同时请求不止一类资源,则需要为最大需求矩阵Max,分配矩阵Allocation和需求矩阵Need增加维数,当然代码量也将大大增加,但是算法逻辑本身并无变化.

读者写者问题：

typedef int semaphore;
semaphore mutex=1; /* 控制对RC的访问 */
semaphore db=1; /* 控制对数据库的访问 */
int rc=0; /* 正在读或想要读的进程数 */

void reader(void)

while(TRUE) /* 无限循环 */
down(&mutex); /* 排斥对RC的访问*/
rc = rc+1; /*又多了一个读者*/
if(rc == 1)
down(&db);
/*如果这是第一个读者，那么......*/
up(&mutex); /*恢复对RC的访问*/
read_data_base(); /*访问数据*/
down(&mutex); /*排斥对RC的访问*/
rc = rc -1; /*读者又少了一个*/
if(rc==0)
up(&db);
/*如果这是最后一个读者，那么......*/
use_data_read(); /*非临界区操作*/



void writer(void)

while(TRUE)

think_up_data(); /*非临界区操作*/
down(&db); /*排斥访问*/
write_data_base(); /*修改数据*/
up(&db); /*恢复访问*/


图2-19 一个读者与作者问题的解决方案
第一个读者对信号量db执行DOWN。随后的读者只是递增一个计数器rc。当读者离开时，它们递减这个计数器，而最后一个读者则对db执行UP，这样就允许一个阻塞的写者可以访问数据库。

设想当一个读者在使用数据库时，另一个读者也来访问数据库，由于同时允许多个读者同时进行读操作，所以第二个读者也被允许进入，同理第三个及随后更多的读者都被允许进入。

现在假设一个写者到来，由于写操作是排他的，所以它不能访问数据库，而是被挂起。随后其他的读者到来，这样只要有一个读者活跃，随后而来的读者都被允许访问数据库。这样的结果是只要有读者陆续到来，它们一来就被允许进入，而写者将一直被挂起直到没有一个读者为止。假如每2秒钟来一个读者，而其操作时间为5秒钟，则写者将永远不能访问数据库，或者我们说写者发生了饥饿现象。这就是读者优先的解法。 参考技术A #include <stdio.h>
#define M 5
#define N 3
#define FALSE 0
#define TRUE 1

int MAX[M][N]=7,5,3,3,2,2,9,0,2,2,2,2,4,3,3;

int AVAILABLE[N]=10,5,7;

int ALLOCATION[M][N]=0,0,0,0,0,0,0,0,0,0,0,0,0,0,0;

int NEED[M][N]=7,5,3,3,2,2,9,0,2,2,2,2,4,3,3;

int Request[N]=0,0,0;

void showdata();
void changdata(int);
void rstordata(int);
int chkerr(int);

int main()

int j=0;
char flag='Y';

showdata();
while(flag=='Y'||flag=='y')

int i=0;
i=-1;
while(i<0||i>=M)

fflush(stdin);
printf("请输入需申请资源的进程号（从0到%d，否则重输入!）:",M-1);
scanf("%d",&i);

if(i<0||i>=M)
printf("\n输入的进程号不存在，重新输入!\n");



printf("请输入进程%d申请的资源数",i);

for (j=0;j<N;j++)

printf("\n 资源%d: ",j);
scanf("%d",&Request[j]);

if(Request[j]>NEED[i][j])

printf("进程%d申请的资源数大于进程%d还需要%d类资源的资源量!\n",i,i,j);
printf("申请不合理，出错!请重新选择!\n");
flag='N';
break;

else

if(Request[j]>AVAILABLE[j])

printf("进程%d申请的资源数大于系统可用%d类资源的资源量!\n", i , j);
printf("申请不合理，出错!请重新选择!\n");
flag='N';
break;



if(flag=='Y'||flag=='y')

changdata(i);
if(chkerr(i))

rstordata(i);
showdata();

else
showdata();

else
showdata();
printf("\n");
printf("是否继续银行家算法演示,按'Y'或'y'键继续,按'N'或'n'键退出演示: ");
scanf("%c",&flag);



void showdata()

int i,j;
printf("系统可用的资源数为: ");

for (j=0;j<N;j++)
printf("资源%d: %d ",j, AVAILABLE[j]);

printf("\n");

printf("各进程还需要的资源量: \n");

for (i=0;i<M;i++)

printf("进程%d:",i);

for (j=0;j<N;j++)
printf(" 资源%d: ", NEED[i][j]);
printf("\n");


printf("各进程已经得到的资源量:\n");
for (i=0;i<M;i++)

printf("进程%d:",i);

for (j=0;j<N;j++)
printf(" 资源%d: ",ALLOCATION[i][j]);

printf("\n");




void changdata(int k)

int j;
for (j=0;j<N;j++)

AVAILABLE[j]=AVAILABLE[j]-Request[j];
ALLOCATION[k][j]=ALLOCATION[k][j]+Request[j];
NEED[k][j]=NEED[k][j]-Request[j];




void rstordata(int k)

int j;
for (j=0;j<N;j++)

AVAILABLE[j]=AVAILABLE[j]+Request[j];
ALLOCATION[k][j]=ALLOCATION[k][j]-Request[j];
NEED[k][j]=NEED[k][j]+Request[j];




int chkerr(int s)

int WORK,FINISH[M],temp[M];
int i,j,k=0;
for(i=0;i<M;i++)
FINISH[i]=FALSE;
for(j=0;j<N;j++)

WORK=AVAILABLE[j];
i=s;
while(i<M)

if (FINISH[i]==FALSE&&NEED[i][j]<=WORK)

WORK=WORK+ALLOCATION[i][j];
FINISH[i]=TRUE;
temp[k]=i;
k++;
i=0;

else

i++;


for(i=0;i<M;i++)
if(FINISH[i]==FALSE)

printf("系统不安全!!! 本次资源申请不成功!!!\n");

return 1;


printf("经安全性检查，系统安全，本次分配成功。\n");
printf("本次安全序列：");

for(i=0;i<M;i++)
printf("进程%d->",temp[i]);

printf("\n");
return 0;


原来如此，我还以为楼主懒得搜索呢。
不过那样的话，对不起。我放弃了。。 参考技术B 什么意思？？？