规则：
应该将修饰符*  和 &紧靠变量名。例如：int  *a;  int &a;
类的版式：
类可以将数据和函数封装起来，其中函数是表示类的行为。也可以称为是服务。类提供了关键字public ,protect ,private用于声明哪些是公共的，哪些是保护的，哪些是 私有的。这样可以让类隐藏必要的东西。
类的版式主要有两种版式:
 (1):第一种将privte类型的数据 写在前面，将public类型的数据写在后面。采用这种版式的程序员主张“以数据为中心，”重点关注类的结构。
 (2):第二种版式是将public类型写在前面。将private写在后面。这种版式的程序员主张“以行为为中心”。重点关注的是类应该提供什么样的接口（或者服务）。
我建议大家采用“以行为为中心的”的这种类的 版式。因为这样设计类的时候。首先考虑的类可以提供什么洋的服务。而且方便用户阅读。

空行：
空行起着分隔程序段落的作用。
(1):在给个类的声明之后，函数的定义之后，都要加上空行。
(2):在一个函数体内，逻辑关系密切的相关语句之间不可以加上空行。
代码行：
(1):一行代码指做一件事情。例如:只声明一个变量。
(2)；if ,for while,do等语句自占一行。执行语句不能紧跟其后。
建议：在定义变量的同时。初始化该变量。
如果变量的引用和定义的地方比较远，那么很容易就会忘记了变量的初始化。如果引用了一个没有初始化的变量，那么很有可能就会引起错误。
代码行内的空格：
(1)；关键字之后要有空格。向const ,virtual,case等关键字后面至少要留一个空格。否则的话，无法辨认关键字。象if.while, for等关键字后面紧跟一个空格在跟“（”以显示关键字的。
(2):函数名之后不要留空格，紧跟“（”以和关键字区别。
对齐：
程序的分界符“{”和"}"应该独占一行并且位于一列。

头文件由三部分组成：
1：头文件开头出的版本和版权的 声明。
2：预处理块。
3：函数和类的结构声明等。
规则：
(1): 为了防止头文件被重复的引用，应该使用#ifndef/define/endif结构产生与处理模块。
(2):用#include<filename.h>来引用标准库的头文件（编译器将从标准库目录开始搜索）。
(3):用#include"filename.h"来引用非标准库的头文件（编译器将从用户工作的目录开始搜索）
建议：头文件中一般只存放“声明”，而不存放“定义”

定义文件的结构：

定义文件的 内容有由三部分组成：
(1):  定义文件开头处的版本和版权；
(2):对一些头文件的引用；
(3):程序的实现体（包括数据和代码）

头文件的作用：
(1):通过头文件来调用库功能。在很多场合源代码不能（或者不准）提供给用户。只提供给用头文件或者二进制的库。用户只需要按照头文件中的接口的声明来调用库功能。而不必关心接口是如何实现的。编译器会从库中提取相应的代码。
(2): 头文件可以用来加强类型安全检查。如果某个接口被实现或者被实用的时候，其方式和在头文件中的声明不一致的时候，编译器就会报错。这一简单的规则可以大大的减轻程序员调试和改错的负担。
目录结构：
如果一个软件的头文件比较多（超过10个），就应该把头文件和定义文件分开。分别保存在不同的目录之中。以便于维护。
例如：可以将头文件保存在inluude目录之中。将定义文件保存在source文件之中。
如果某些头文件是私有的，不会被程序直接引用，为了加强信息隐藏。那么可以把这些头文件和定义文件放在同一目录之中。

指针中存有另一个对象的地址，使我们可以间接的操作这个对象。
指针的典型用法是构建一个连接的数据结构，例如：链表(list)和数(tree)。并管理在程序运行的过程中动态分配的对象。以及作为函数参数类型。主要用来传递数组和大型类的对象。
每个指针都有相关的类型。
不同数据类型的指针之间的区别不在于指针的表示上，也不是指针所持有的值（地址）。——对于所有类型的指针这两个方面都是一样的。不同之处在于指针所指的对象的类型上。针织类型可以指定编译器咋样解释特定内存上的指定的内容，以及该内存区域因该跨越多少内存单元。

变量名，即变量的标识符，可以由字符，数字，以及下划线来组成。他必须以字符或者下划线来开头，并且区分大小写。
语言本身没有对变量名做什么限制。但是为了用户着想，他不应过长。
c++保留了一些词用作关键字。关键字标识符不能在作为标识符在程序中使用了。
对于命名对象有很多已经普遍接受的习惯。主要考虑的因素的是程序的可读性。
第一：对象的命名一般用小写。
第二：标识符通常用容易记忆的名字。
第三：对于多词构成的标识符一般在词的中间加上下划线。
对象的定义：
一个简单的对象的定义由一个类型指示符后面加上一个名字构成，以分号结束。
例如： int aaaaa;
当同类型的多个标识符被定义的时候，我们可以在类型指示符后面用逗号隔开。
一个简单的定义指定了变量的类型和标识符。他并不提供初始值。
如果一个变量是在全局域（globe scope）中定义的,那么系统会保证给他一个初始值0。如果一个变量是在一个局部域中定义的，或者通过一个new 动态分配的，那么系统不会向它提供初始值0。这些对象被称为未初始化（uninitialized）,未初始化的对象不是没有值，而是对象的值未被定义。
因为使用未初始化的对象是个很常见的  错误，并且很难被发现。所以建议为每个定义的对象进行初始化。
类机制通过缺省构造函数提供了类对象的自动初始化。
例如：
int  main()
{
int val；////////未被初始化的值。
string  project；//////通过string类的缺省的构造函数进行了初始化。
}


val是一个未被初始化的局部变量。
但是project是一个已经被初始化的类对象——被string类缺省的构造函数自动初始化。
初始化一个值可以在对象定义的时候进行。
c++支持两种形式的初始化。
第一种是使用赋值符号的现实的操作。
如：
int val=111;
string  project="ssssss";
隐式形式中，初始化值被放在括号中。
int val(111);
string project("sssssss");
在对象的定义之中，当对象的标识符在定义中出现后，对象名马上就是可见的了。因此用对象初始化他自己是合法的，只是这样做不是明智的。
例如：int val=val;///////合法，但是不是明智的。
另外，每种内置数据类型都支持一种特殊的构造函数。可将对象初始化为0。
/////设置val为0。设置dval为0.0。
int val =int();
double dval=double();
下列的定义中：
int()
vector <int>ival(10);
函数int()自动被应用到ival包含的10个元素上。
对象可以用任意复杂的表达式来初始化，也可以用返回值

变量为我们提供了一个有名字的内存存贮空间。可以通过程序对其进行 读写，处理操作。
c++中给个符号变量都有一个符号类型与之对应。这个类型决定了相关内存的大小，类型，布局，能够存贮在该内存值的范围。以及可以以用到其上的操作集。我们也可以把变量说成是对象（object）
。
变量和文字常量都有存贮区，并且都有相关的类型。区别在于变量是可以寻址的（adressable）常量文字是不可以寻址的（nonadressable）,每一个变量都有两个值与之联系着，
1：数据值。存贮在内存的某个存贮区之中。有时候这个数据值也被称为是右值（rvalue）.我们可以认为右值是被读取的值。文字常量和变量都可以被用来做右值。
2：它的地址值。即存贮它数据值的那块内存的地址。它有时候被称为左值（lvalue）。我们也可以认为左值的意思是位置值。文字常量不能被用作左值。
变量的定义会引起相关内存的分配。因为一个对象只能有一个存贮位置，所以一个对象只能被定义一次。如果在一个文件中定义的对象需要在另一个文件中被访问，那么就会出现问题。
在c++中，对象在使用之前必须知道对象，引用一个未知的对象会引起编译器的错误。
如果一个对象在另一个  文件中声明着，我们想在这个文件中来使用这个对象，但是又不能在这个文件中在声明相同的对象。那么我们可以使用extern关键字来声明这个对象。
例如; file module.c
 string aaaaa;
///定义了对象aaaaa



file  module1.c
////需要使用对象aaaaa.，
////声明对象aaaaa，使程序知道它。但是又不能引入第二个定义。
extern string aaaaa;
对象声明是使程序知道对象的类型和名字。它由关键字extern后面跟对象的类型和对象的名字构成。
声明不是定义，不会引起内存的分配。实际上它只是说明了在程序之外的某处有这个变量的定义。
虽然一个程序中只能包含一个对象的定义，但是可以包含很多的对象声明。
比较好的做法是:   不是在每个要使用的文件中都单独提供一个声明。而是在在头文件中声明这个对象，然后在需要声明这个对象的时候包含这个头文件就好了。按照这个做法。如果需要修改对象的声明只需要修改一次。就能维持多个使用这个对象的声明文件的一致性。

面相对象的程序设计扩展了给予对象的程序设计。可以提供类型和子类型的关系。这个是通过一种称作继承（inheritance）的机制来实现的。

c++預定了一組數值數據類型。可以用來表示整型，浮點型和單個字符。此外還預定了表示字符串的字符數組。
1：字符型char:通常用來表示單個字符和小整數。它可以用一個機器字節來表示（即8位表示）。
2：整型int  短整型short ，長整型long分別表示不同長度的整數值。典型的情況下：short用半個字表示（即16位）。int 用一個字表示（即32位。）long用一個或者兩個字表示。（在32位的機器中通常int 和long的通常長度相同。）
3：浮點型flont ,雙精度double和長雙精度。長雙精度long double 。分別表示單精度浮點數。雙精度浮點數和擴展精度的浮點數。典型的情況下，float用一個字表示。double用兩個字表示，long double用三個或者四個字表示。
char ,int, float , long 稱為整值類型（intergral  type）。整值類型可以有符號也可以沒有符號。在有符號的類型中。最左邊的位是符號為。余下的位代表數值。。在無符號的類型中，所有的位表示數值位。
如果符號為被設置為1。那么數值被解釋為負數。如果符號為被設置為0。那么數值位被解釋為正數。
一个8位有符号的char 表示-128---127之间的值。而一个无符号的char则表示0--255之间的值。
当一个值。例如1。出现在程序的时候，我们称它为文字常量。称他为“文字”是因为我们只能以他的值的形式来指代它。称之为常量是因为它的值不能被改变。每个文字都有相应的类型。文字常量是不可寻址的（nonadressable）。尽管他的值也被存储在机器的某个内存之中。但是我们没有办法来寻找它的地址。
整数文字常量可以被写成十进制。八进制，十六进制的形式。（这不会改变该整数的位序列）。例如：20可以写成以下的方式：
20/////////十进制形式
024/////八进制
0x14////十六进制。
在整型常量前面加上0。该值将被解释成一个八进制数。而在整形常量的前面加上0x，则该值将会被解释成十六进制数。
在缺省的情况下，整形常量被当作一个int的有符号的整数。
我们可以在一个文字常量的后面加上一个“L”或者"l"，将其指定为long类型。
类似的，我们在文字常量的后面加上“u”或者“U”。表示一个无符号的数。
此外，我们还可以指定无符号long类型的数。例如： 1UL.
单词true 和false是bool型的文字常量。
可以打印的文字常量可以用单引号''括起来例如：
'A','S'...等。
不能够直接打印的字符，单引号，双引号，和反斜杠就i可以用转义序列来来表示（转移序列用反斜杠来开头）。
\n 换行符
\t水平制表符
\v垂直制表符
\b退格符
\r回车键
\a响铃建
\\反斜杠键
\?问号
\'单引号
\""双引号
另外字符文字前面可以加上“L
例如：L'a'
这个称为宽字符文字，类型为wchar_t.宽字符常量用来支持某些语言字符的集合。例如：汉语，日语等
这些语言中的某些字符不能用单个的字符来表示。
字符串常量由零个或者许多个由双引号括起来的 字符
不可以打印的字符由相应的转移序列来表示，而一个字符串文字可以扩展到多行。在一行的最后加上一个\，表示字符串文字在下一行继续。
如："fdfdf fdfdf\dfdfdfsdffdfdfdf"
字符串文字的类型是常量字符数组。字符文字本身和 编译器加上的表示结束的(NULL),字符构成。
例如：'a'表示一个单个的字符a
"a"则表示一个字符a和一个空字符，
空字符是c和c++用来标记字符串结束的符号
正如宽字符文字。L'a'

也有宽字符串文字L"aaaaaaa"
宽字符串文字的类型是常量的宽字符数组。他也有一个等价的宽空字符作为结束的标记。
如果两个字符串和或者宽字符串在程序中相邻。c++就会把它们连接起来。并且在最后加上一个空字符，
例如："one" "two" 则输出的结果为onetwo.
如果把一个字符串常量和一个宽字符串常量链接起来，那么结果会是如何呢？
"aa" L"SSS"
结果是未定义(undefine)------即没有这种这两种不同类型链接标定义行为。
使用未定义的程序被称为是不可以移植的。
虽然程序可以在当前的编译器下可以执行，但是不能保证相同的程序在不同的编译器下，或者在当前的白一起的以后的版本中，还能够正确的编译通过。
在本来可以正常运行的程序中来寻找这些是件很令人心烦的事情，所以我们建议不要使用未定义的程序特征。

正如我们看到的，尽管c++的数组支持容器机制。但是它不支持容器抽象的语义。为了在这个层次上编写程序。在标准c++之前。要么我们从某个途径获取这样的类。要么我们自己编写这样的类。
在标准c++中。数组类是c++标准库中的一部分。现在它不叫数组了，而叫向量(vector)、

当然向量是一个类模板，我们可以这样写：
vector<int> ivec(10);
vector<string>svec(10);
上面的代码分别定义了包含10个整型的对象的向量，和定义了包含10个字符串的对象的向量。
在我们实现的Array类模板和vector类模板的实现中有两个不同的区别;
vector类模板支持“向现有的数组元素赋值”的概念以及“插入附件元素的”概念---------即vector数组可以在运行时动态的增长。（如果程序员愿意使用这个特征的话。）
第二个区别是 ： 更加广泛。代表了设计方法的重要改变。vector类不是提供一个巨大的“可以适用于向量”的操作集。如;store(),min().max()等。而是只是提供一个最小集；如：等于，小于，size(),empty()等操作。而一些通用的操作如：sort(),min().max(),find()。等操作是作为独立的泛型算法（generic algorthem）被提供的。
要定义一个向量我们必须包含相关的头文件。
#include<vector>
下面都是vector对象的合法定义。
vector<int>vecto;///////空的vector
const int size=8;
const int value=1024;
//size为8的vector
///每个元素都被初始化为0
vector<int>vecto(size);

//size为8的vector
///每个元素都被初始化为1024
vector<int>vecto(size ,value);
////vector3的size为8
///vector3的初始化值为ia 的4个值
int ia[4]={0,1,1,2};
vector<int>vector3(ia,ia+4);

////vector4是vector2的拷贝。
vector<int>vector4(vector2);
既然定义了向量，那么我们就必须遍历里面的元素。
与Array类模板一样。标准的vector类模板也支持使用下面的操作符。
例如：
#include<vector>
extern int getsiz();
void mumble()
{
  int size=getsize();
vector<int>vec(size);
for(int i=0;i<=size;i++)
{
 vec[i]=i;
/////,.............................
}
}

名字空间允许我们封装名字，否则的话，这些名字就有可能污染到全局的名字空间（pollute teh global namespce）.一般来说，只有我们希望我们的代码被外部软件开发部门使用的时候。才会用到名字空间。
例如;我们可以这样来封装Array类，
namespace cplacple_primer_3E
{
 template <calss eyemly>
 calss Array{,,,,,,,,,};
////////////////////////

}
namespce后面的名字标明了一个名字空间。它独立于全局名字空间。我们可以在里面放一些希望声明在函数和类之外的实体。名字空间并不改变他们的声明意义。只是改变了它们的可视性。如果名字空间中的声明对于程序来说不是立即可见的。那么我们杂样来访问他们呢？我们就要用到限定修饰名字符.
格式如下：
namespce_idenerfier::entrityname
名字空间别名（namespce alias）允许用一个可替代的，短的，或者跟一般的名字来和名字空间来关联起来。
例如：
//提供一个更一般化的名字
namespce lib=cplacple_primer_3E
然后这个名字就会称为原始名字空间的同义词。
#include "cplacple.h"
int main()
{
 lib::Array{...........}

 }
别名也可以 用来封装正在使用的实际的名字空间。在这种情况下，我们可以通过改变别名的名字空间。
来改变所使用的声明集。而无需改变“通过别名来访问这些声明”。的实际代码。
using 指示符使名字空间中的所有的声明都是可见得。这样这些声明可以不加任何的限定的使用。
using和namespce都是关键字。被引用的名字空间必须已经被声明了。否则的话，会引起编译的错误。

using 声明提供了更为精细的名字可视化机制。它允许使名字空间中的单个的声明可见。
例如：
#include"IBM_Canada_Labaraory.h"
using  namespace IBM_Canada_Labaraory::Matriy
int main()
{
 //ok; IBM_Canada_Labaraory::Matriy

Matriy met(4,5);
//fail,错误。IBM_Canada_Labaraory::Array不可见
Array array(4,5);
}
为了防止标准的c++库组件污染用户定义的名字空间。所有的c++库组件都声明在一个称为std的名字空间中。
所以即使我们在我们的文本文件中已经包含了c++库头文件，头文件中声明的内容在我们的文本文件中也是不可见的。
例如：
在c++中下面的代码是不能被编译通过的。
#include<string>
///错误。string 是不可见的
string  current_string="asdf dfdff";
在string 头文件中所有的声明都包含在std名字空间中。
我们可以用“#include 指示符后面加上using 的办法使在<string>中的，在std中声明的组件，对于我们的文本文件是可见得。
例如：
#include<string>
 using namespace std
int main()
{
 //////////正确。string 是可见的。
  string current_string="asd fdfdf"
}
为了使在std中，声明的组件和名字在我们的文本文件中可见。using指示符通常被看作是一种比较差的选择方案。
在上面的例子中。指示符using ，使在string头文件中声明的，并且在std名字空间中的  组件在我们的文本文件中都是可见的。这又将全局名字空间污染问题带回来了。而这个问题就是std名字空间首先要努力避免的。
它增加了“c++标准库组件的名字”与“我们程序中声明的全局名字”冲突的机会。
现在有两种机制可以替代using指示符。来引用隐藏在std名字空间中的名字string.
第一种方法：
 可以使用限定的名字。
  #include<string>
/////正确。使用限定的名字
   std:: string current_string="afdfdfsdfs";
第二种方法：
 如下使用using 声明；
#include<string>
 using std::string;
 /////ok.上面的using声明使string可见。
 string=“dfdfdfafsdf”;
为了使用名字空间中的声明的名字。最好使用带有精细选择功能的 using声明替代using 指示符。

异常(exception)是指在运行的时刻程序出现反情况。比如：数组下标越界。打开文件夹失败，动态创建内存失败等。程序员一般有自己的异常处理方式。这导致个各种编码方式，。所以很难整合到一个程序中。
异常处理(exception  handing ), 为“响应运行时刻的程序“提供了一个标准语言级的设施。它支持统一的语法和风格，也允许每个程序员进行微调。异常处理                不需要我们在程序中处处显示的测试异常状态。从而可以将测试代码显示的抽取出来，放在指定的 标记的代码块中。因此 异常处理设施大大的 简化了程序的长度和复杂度。
异常处理机制主要构成如下：
1： 程序中异常出现的点。一旦识别出程序的异常，就会抛出异常(throw)。当异常被抛出的时候，程序就会被挂起，知道异常被处理完毕了。c++中，异常的处理有throw表达式来执行。
2：程序中异常被处理的点. 典型的程序的异常抛出和处理位于独立的 函数或者成员函数中。找到异常处理代码一般要展开程序调用栈(progam call stack ).一旦异常被处理完毕，及恢复程序的正常执行。但是不是在出现 异常的地方恢复，而是在处理异常的地方恢复执行过程。在c++中异常的处理用catch表达式来执行。
catch和try字句相关联。一个try块用一个或者多个catch子句将一条或者多条语句组织起来。
系统根据被抛出的异常和catch子句的异常类型的匹配的情况来选择catch子句。
系统把控制传递给catch子句体，其中的语句将顺序执行。完成后后，除非子句体中还抛出异常，否则的话，控制将会被传到程序的当前点上。

c++的模板提供了一种机制，它能够把函数和类内部的数据和值参数化。这些参数在其他地方不变的代码中用作占位符。以后，这些参数会绑定在实际的数据类型中。可能是内置的数据类型，也可以是用户自定义的 类型。

在c++ 中，被继承的类称为基类（base class）新类  被称为从基类中派生（derived）来的。我们把它叫做派生类或基类的子类。子类和基类共享公共的接口（common interface--）-----共有操作的公共集.由于共享公共接口，就允许子类和基类在程序内部可以互换使用。而无需考虑对象的类型。从某种意义上说，公共接口接口封装了子类型中与类型相关的细节。类之间的类型和子类型形成了继承和派生层次关系。
在继承的机制下有多个  类的提供者：一个提供基类的实现（可能还提供一些派生类的实现。另外一个或者多个提供者在集成生命周期内提供派生类）。子类的提供者经常要访问（并不总是)基类的实现，为了提供这种能力，同时也为了能够还要防止对积累的一般性的访问，c++中提供了另一种访问级别：保护。在类的保护区域的成员函数和数据成员只提供给它的派生类使用，放在基类的数据成员和数据成员只能被它自己使用，它的派生类也不能使用使用它。

             

更一般的，c++支持函数重载(funtion  overloding)的机制。c++允许两个或者两个以上的函数具有相同的命名字。限制条件是参数的不同，可以是参数的类型或者数目的不同。根据不同的参数表。编译器就可以区分开调用哪个函数。
重载函数和非重载函数在运行时刻的行为是一样的。只是重载函数在运行的时候，会花费时间来决定到底用哪个函数。如果c++不支持函数重载的话。那么我们就必须为每个函数设置不相同的名字。
如果在类的体外进行成员函数的定义的时候，就必须指出这个成员函数属于哪个类。这个可以通过类的域操作符（calss  scope operator）来实现。
例如：Inarry::
":"冒号操作符被称为域操作符。
当与一个类相连接的时候。它就成为一个域操作符了。
我们可以非正式的把与看作是一个可视的窗口。非全局域的文件在它的这个文件中都是可见的，在一个函数体内定义的对象是局域的，它只在这个函数体内可见。每个类维持一个域。在这个域之外，它的成员是不可见的。类域操作符告诉编译器。域操作符后面的内容是可以在这个域中找到的。
引用：引用是一种没有指针语法的指针。与指针一样，引用提供对对象的间接访问。
类机制还支持特殊析构成员函数（destructor member funtion ）每一个类对象在最后一次被使用之后，析构函数就会被自动调用。
我们在析构函数前面加上~线来标识。一般来说，析构函数释放类对象和在构造函数中所获得的资源。

基于支持对象的类的形式为：
class classname
{
 public////////公有操作集合
private:
//////私有实现代码

}
这里的class，  pulic。和private 是c++的关键字。classname是一个标识符，用来命名类名。以便以后引用该类。
类名代表着一种新型的数据类型，我们可以像定义内置的数据类型一样来定义对象。

例如：
Inarry    inaaay;////定义一个单个类Inarry的对象inaaay;
Inrry *inarry=new Inrry;///////定义一个指向Inrry类的对象的指针。
类的定义包含两个部分：
类头（ class head）有关键字class和类名组成。类体（class boday）有花括号括起来。以分号结束。
类头本身也做类的声明。
类体包含成员定义和访问标签。如:public和private。成员定义主要包括：“该类主要实现什么洋的功能，”以及   “代表类抽象所需要的数据”这些操作称为成员函数(member funtion)。或者称为方法（methord)。
程序设计中一个常见的错误是使用先前没有正确被初始化的对象。实际上这是一个十分常见的错误。所以c++为用户定义的类提供了一种自动初始化机制：类的构造函数（calss  constructor)
构造函数是一种特殊的成员函数。专门用于初始化对象，如果构造函数被定义了。那么每个对象在应用的时候，该构造函数就会被自动的应用到该对象上。构造函数由类的提供者来定义。既我们提供类的定义的时候。就必须定义类的构造函数。
为一个类定义一个构造函数是类设计必不可少的一部分。
为了定义一个构造函数。我们只要  给出一个和 类名字相同的函数就可以了。
不能指定构造函数有返回值。可以定义很多的构造函数在一个类中。
尽管她们具有相同的名字，但是只要编译器可以根据参数区分他们就可以了。
更一般的
。

在c++中，内存可以是静态分配的——编译器在处理源代码的时候就分配，也可以是动态分配的---程序在 运行的时候调用所需要得库函数进行分配。这两种分配方式各有个的优点。由于静态内存分配是在程序运行之前就分配了内存，所以执行的效率就很高。但是缺乏灵活性。它要求知道程序在之前就知道内存的类型和数目。
例如：
利用静态分配的字符串数组，我们就无法很容易的处理和存贮任意的文本文件。一般来说存贮未知的的数目的元素，需要动态分配内存的灵活性。
例如：以下的定义：
int ival=1024;
指示编译器分配足够的内存来存贮一个整型值。该存储区与名字ival相关联。然后用1024区初始化该存贮区，这些都是在程序之前完成的。
c++支持用指针类型来存放对象的内存地址值。
例如：
为了声明一个存放ival内存地址的的指针类型。我们可以声明如下：
int *print;//////一个指向int类型的指针。
c++预定一个专门取地址的操作符（&），当他应用于一个对象上的时候，返回的是该对象的地址。
因此，为了将ival的地址值赋值给print，我们可以写为：
int*print;
print=&ival;///把ival的地址值赋值给print
为了访问print所指向的内容。我们必须先用解引用（dereference）操作符（*），来先解除的引用。
例如：我们通过print间接的给ival加1；
*print=*print+1;
等价于：
直接对 ival进行操作
ival=ival+1;
在c++中指针主要是用来管理和分配动态分配的内存。
对象的分配可以通过两个不同的版本来实现。
第一个版本用于分配特定类型的单个对象。
int*print=new int 1024);
分配了一个没有名字的int类型的对象，对象的初始化值为1024。然后表达式返回对象在内存中的地址。
接着这个地址用来初始化指针对象print.    对于动态分配的内存。唯一的访问方式是通过指针来访问。
例如：
new的第二个版本，用于分配特定的类型和维数的数组。
int *pia=new int[4];
分配了一个含有4个元素的整型数组。不幸的是我们没有办法给动态分配的数组每个值显示的指定一个初始值。
分配动态数组，一个常令人困惑的问题是，返回值只是一个指针。与分配单一对象的返回值是相同的。

数组是一组具有相同数据类型的元素的集合。
c++为基本算术数据类型提供了内置的支持。同时他也支持双精度和单精度的数据支持。除此之外c++还支持布尔类型，以及用来存放字符集中单个元素的字符支持。
在内置数据类型和标准库类类型之间的是复合数据类型（compuond type）特别是指针和数组类型。
数组(array)是一个顺序的容器.它包含单一类型的元素。
例如：序列
0 1 1 2 3 5 8 13 21
代表菲波那契序列的前9个数。（只要给出前两个数据，后面的数据就是前两个数据的之和。）
a[8]={0,1,2,3,4,5,6,7}
当a[9]的时候，就会出现一位偏移错误（off-by-one）：
通常我们用循环来遍历数组中的元素。
例如：下面的程序初始化了一个数组。前9为分别为0---9
int main()
{
  int ia[10];
  int idex;
 for(idex=0;idex<10;idex++)
{
 ia[idex]=idex;
}
for(idex=9;idex>=0;idex--)
{
 cout<<ia[idex]<<"";
cout<<endl;
}
}
c++虽然对数据类型提供了内置的支持。但是这种支持只是限定于“读写单个数组元素”。c++不支持数组的抽象（abstracion）,也不支持对整个数组的操作.我们有时候希望对整个的数组进行操作。例如：把一个数组赋值给另一个数组。对两个数组进行比较。。想知道数组的大小。
例如：给出两个数组，我们不能直接用赋值操作符，把一个数组的值拷贝到另一个数组中去。
比如：
ia1[10], ia2[10]
ia1[10]=ia2[10];/////错误。不能直接把一个数组的值通过赋值运算符赋值给另一个数组。
如果想把一个数组的值赋值给另一个数组我们必须自己编写程序。
for(int idex=0;idex<10;idex++)
{
  ia1[idex]=ia2[idex];

}

而且数组类型并没有自己的意识。它并不知道自己的长度，我们必须另外记录数组的信息。当我们希望把一个数组作为参数传递给一个函数的时候，问题就出现了。在c++中，数组不同于整型类型和浮点类型，它不是c++的一等公民（first——class），它是从c语言中继承而来的，它反映了数据与对其进行操作的算法的分离。这正是过程话程序的特点。

c++的输入输出功能是由输入输出流（iostream）库提供的，输入输出流库是c++面向对象类层次的一个结构，也是c++库的一部分。
终端的输入也称作是标准的输入(standard input ),与预定义的iostream 对象sin 绑定在一起。
终端输出，也称作是标准输出（standard output ），与预定义的iosream的对象cout 绑定在 一起。
第三那个预定义对象cerr，也称为标准错误。也终端绑定。cerr通常用来给程序用户提示错误的 信息，以警告的信息。
任何想使用iostream库的文件都要包含，相关的头文件。
#include< iostream.h>
输出操作符<<用来把一个值导向cout标准输出或者cerr标准错误上。
例如：
cout<<"\n"； 中的“\n表示换行符(new line),输出换行符的时候，它结束当前的行，并将输出导向下一行。
除了显式的使用"\n"进行换行外，还是可以使用预定义的iostream 操作符endl。进行换行。
操作符在iostream上，进行的是一个操作，而不只是简单的提供一个数据。 
文件的输入和输出：
iostream库也支持的输入和输出。所有能应用在标准当输入和输出的上的操作，也都可以应用在已经被打开的输入和输出文件上。
为了打开一个文件供输入和输出，除了包含iostream外，还必须包含头文件，
#include<fstream>
为了打开一个输出文件，我们必须声明一个ofstream类型的对象。
ofstream outfile("name_of -files");
为了测试是否成功的打开一个文件，我们可以用下面的代码：
if(!outfile)
{
///如果文件不能打开，值为false

}
类似的，如果我们打开一个文件供输入，那么我们必须声明一个ifstream的对象。
ifstream infile("name-of  _files")
if(!infile)

例如：
c++中
从一个文本中1.txt中读内容到2.txt中，
#include<iosrteam>
#include<ftream>
#include<string>
using spacename std;//////注意这里。

注释是用来帮助程序员来读程序结构的与语言。它是一种礼仪，可以用来说明变量的意义或者用来某一段难懂的代码。注释不会增加可执行代码的长度，在生成可执行代码之前编译器会将注释的部分从程序中去除的。
c++中有两种注释符，一种是注释对（/**/）。与c语言一样，注释的部分放在/**/之间。编译器会将/**/之间的代码当作注释部分，注释的可以放在任何位置。可以含有制表符，空格， 可以跨几行。
第二种注释就是//双斜线。它可以注释单行的内容，注释符右边的内容都会被当作注释的内容而被编译器忽略。

assert()是c语言标准库提供的一个通用的标准库预处理器宏。在代码中经常用assert()来判断一个必须的前提条件。例如：要打开一个文件，我们必须先知道合格文嘉你的名字，然后在可以打开为了使用assert()必须包含与之对应的头文件
#include < assert.h>
下面是一个简单的例子：
assert(filename!=0);
判断是否文件的名字为0。建兴断言，如果文件的 名字为0，那么断言失败，输出错误的诊断信息，然后中止程序。
assrt.h是c标准库头文件的c名字。c++程序可以通过使用c的库头文件的c名字或者c++的名字来使用它。
这个头文件的c++名字是cassert. c库头文件的c++名字总是以c开头，后面跟的是c名字去掉.h的名字。（因为c++中，头文件的后缀各不相同，所以标准的c++没有指定头文件的后缀）.
使用c库头文件名字和使用c++的名字，那么#include 预处理器的效果也是不一样的。
例如：下面的#include指示符;
#include<cassert>
当我们把这个头文件读入我们的文本文件中的时候，头文件中的内容 好似不可见的。因为所有的c++库名字是在std名字空间中定义的。所以我们的文本文件是不可见的。除非我们使用using指示符显示地使其可见。
using  namespace  cassert;
使用c库的头文件就可以直接的在文本文件中使用assert()。而无需使用using指示符了。

编译c++的时候，编译器自动定义了一个预处理器名字_ _cplusplus,(注意前面有两个下划线)。
因此我们可以根据它来判断程序是否为c++程序，以便有条件的包含代码。
例如：
#ifdef _ _cplusplus
//不错，我们要编译c++
//extern "c"我们在第七章在讲解
extern"c"
#endif
min(int ,int );
在编译c的时候，编译器定义一个_STDC_，当然_ _cpluscplus和_STDC_不会同时被定义的，
另外两个比较有用的名字是_LINE_和_FILE_。其中_LINE_是指已经编译的行数。_FILE_包含正在被编译的文件的名字。
另外两个预定义的名字是：_TIME_和_DATE_它们分别包含被编译文件的时间和日期。
时间的格式为：hh:mm:ss
例如：如果你是在正8点17分编译这个文件，那么时间表示为8：17：00。如果那天刚好为1998年10月23号，那么日期就为：oct23 1998
如果当前的或者文件的名字发生了变化，那么预定义名字_LINE_和_FILE_就会变化，其他的预定义名字在编译期间不会变化的。她们的值也不能被修改

头文件通过预处理器标识符(include)而成为我们程序的一部分。预处理器标识符用“#”来标识。这个符号放在程序的最开始 的第一行的位置上。处理这些标识符的程序称为预处理器（preprocessor），一般绑定在编译器中。
include 指示符读入指定文件的内容，它有两种格式：
#include<iostream>
#include"iostream"
如果文件名用"<"和 ">"括起来。那么表示这个文件是一个工程文件或者标准的头文件。查找过程会检查预定义的目录。我们可以通过设置搜索路径环境变量或者命令行选项来修改这些目录。
如果文件是用引号括起来的，就表示这个文件是用户自己提供的，那么查找这个文件的时候，就可以从当前的目录开始查找，
被包含的文件可能还会包含#include,一个同文件可能会被同一个原文件多次的包含。条件指示符可以防止这种头文件被重复包含的情况。
例如：
#ifndef   BOOKSTORE_H
#define BOOKSTORE_H
/*bookstore.h的内容*/
#endif
条件指示符#ifndef用于检查预编译器常量BOOKSTORE_H是否已经被定义了（习惯上我们把与编译器常量用大写表示）。如果BOOKSTORE_H没有在前面定义的话，那么#ifndef 的值为真。那么#ifndef 和#endif中间的语句

将会被执行，否则的话，之间的语句就会被忽略。
为了保证头文件只被处理一次。把如下的的头文件放在#ifndef的后面。
#define指示符放在#ifndef的后面。这样头文件在第一次包含的时候，BOOOKSTORE_H就被定义了，那么以后如果在出现包含头文件的情况，则 #ifndef的值就为假了。
只要不存在“两个必须包含的头文件使用同一个预编译器常量”这种情况，那么这种机制就会很好的运行。
#ifdef指示符用来判断一个预定义器常量是否已经被定义了，以便有条件的包含程序代码。

注意：
#ifndef条件指示符和ifdef指示符的区别。
前者用于防止头文件被重复包含，而后者则是为了判断一下一个预定义器常量是否被定义了。


我们在编译程序的时候，可以使用-D，在——D的后面写上预处理器常量的名字，这样就可以在命令行中定义一个与处理器的常量了。
$CC -DBOOKSTORE_H   main.c
也可以用#define指示符来定义一个预处理器的常量。

我们的程序是由算法和数据组成的。算法是（就是将指令组织起来实现特定的功能），
在c++语言中，动作 被称为表达式（expression）,以分号结尾的表达式称为语句。在程序中最小的单元是语句（statement）.
 函数：把语句按照逻辑分组，就形成了某些单元，。这些单元称为函数(funtion)。
函数由四个部分组成:函数返回值的类型，函数名，参数列表，函数体，前三个组合起来称为函数原型（funtion prototype）.
函数的参数由一个或者多个逗号隔开，由一个小括号括起来。函数体由一对花括号括起来。
return 语句是c++语句提供的预定义的语句，它提供了一种中止函数执行的方法。当return返回一个值的时候。例如：0 ，就表示这个函数返回了这个值（return value）。在标准的c++中当函数没有显示的返回值的时候，默认的函数返回值为0。
void 用来指定一个没有返回值的函数。
#include 是预处理器指示符（preprocessor directive）
在c++标准库中的名字。如：cout 不能直接在程序中使用，除非在预处理器标识符：#include<iostream>的后面使用 using  namespce std;
这条语句被称为using 指示符（using directve）,c++标准库中的名字在我们的程序的文件是不可见的，它们都是在一个名字空间中声明的。我们只有显示的使用它们。这样的话，这些声明在名字空间中的名字才有可能在我们的文件中可见。using 告诉编译器使用在std名字空间中的名字。
编译器的一部分的功能是：分析程序代码的正确性，另一个功能是转换正确的程序代码。这种转换称为代码的生成（code generation）,一般的情况下这些会生成汇编指令或者目标代码。这些目标代码可以被运行这些程序的计算机所理解。
成功编译的结果是一个可执行的文件。
c++定义了一组内置的数据类型，这些数据类型是：整型（int ）,浮点型（float）,布尔型(ture,和false ),字符类型，
在这些内置的数据类型之间可以隐式的发生转换（conversion）.
c++标准还提供了一组扩展的数据类型。字符串类型（string）,复数类型（complex number ）,列表（list）,向量（vector）.

动态连接是一种（juest-in -time）连接。这个就是以意味着，程序在执行的时候要能正确的找到函数库，连接器通过把库文件名和路径名植入到可执行文件中做到这一点，这就意味着函数库的路径不可以随意的改变。
使用静态连接的最大危险在于，将来版本的操作系统可能会和现在可执行文件所绑定的系统函数库不兼容。
函数库链接的5个秘密：
1;动态链接库文件的扩展名字是 ".so"，而静态连接库文件的函数名字是".a".

比较数组和指针的区别，就是比较它们各自的特点：
第一：指针中保存的是数据的地址，而数组保存的是直接的数据。
第二：指针是间接的访问数据，首先得到指针的内容，然后以这个指针的内容作为地址，通过这个地址来访问数据， 而数组则是直接访问数据，a[i]表示以a[i-1]为地址来访问数据。
第三：指针通常用于动态的数据结构，数组一般用于存贮固定数目且数据类型相同的数据元素。
第四：指针相关的函数为mallo(),free(),数组隐式的分配和删除
第五：指针通常指向匿名数据，数组本身就是数据名。

数组和指针都可以在它们定义的时候，用字符串常量来初始化。虽然形式是一样的，但是底层的机制却是不一样的。
指针在定义的时候，编译器并不为指针所指向的对象分配空间，而只是为其本身的分配空间。除非在定义的时候用字符串常量进行初始化。但是只能用字符串常量进行初始化，其他的象浮点型，int型的常量是不可以的，编译的时候会出现无法编译的错误。
例如：char* p="dfdf f "(为其分配了内存空间)
   char*p=3.14//会出现编译错误
在ASCI C中，初始化指针的字符串常量被定义为只读。如果试图通过指针来修改字符串常量的内容，就会出现未定义的行为。有些编译器中，把这些字符串常量保存在一个只读的文本中，防止被修改。
数组也可以用字符串常量进行初始化，与指针相反的是用字符串常量进行初试话的数组，可以被 修改的，单个字符在以后中是可以改变的，例如：
 char butter[]="ff ff ff ff";
 strncpy(butter,"111",5);
结果就是 char butter[]="111fff';

为您介绍简单方法就是可以从SQL Server Online Book开始学习SQL服务器的所有内容，并配合SQL Server开始安装、设置和使用了。

　　当你进入了编程环境，就可以建立数据库并使用不同的工具来学习数据库的各种方法，例如设计一个逻辑数据模型并执行它。因为SQL与数据的操作有关，你可以使用其各种特性，还可以建立存储程序，触发器，查看等功能。

　　提醒您不要忽略安全机制和性能调试，对于一个数据库而言，观察并调试使之顺利平稳地工作是至关重要的。除此之外，MCDBA考试还包括与性能调试和特定程序相关的问题。

　　下面是在辅导下已经通过MCDBA的学员总结的一些学习经验：

　　1、先熟悉MMC，即Enterprise Manager的操作；

　　2、学会用SQL Query Analyzer分析你的SQL语句执行效率；

　　3、使用存储过程/视图/以及SQL Server特有的服务；

　　4、学会使用Profiler来调试你的客户端程序；

　　5、学习数据库管理技术；

　　6、熟读SQL Server Online Book非常有用！如果不怕辛苦看一遍很值得。

http://www.verycd.com/topics/160024/

http://www.verycd.com/topics/64762
http://www.verycd.com/search/folders/mcse
http://www.mcse.org.cn/showtopic-4987.aspx 
http://www.mcse.org.cn/showforum-2.html
http://www.verycd.com/search/folders/mcse
http://bbs.tech.ccidnet.com/read.php?tid=283574
http://www.zuowenw.com/jsjks/microsoft/kaoshifudao/MCDBA/
http://www.softii.com/downlist/s_313_2.html

软认证心得：拿下微软四个证书

2007-06-01 10:08:29　来源：考试大 地区：北京 关键字：考经  收藏到好诶

  我本人算是半个IT工作者，所谓半个，是因为我每天的工作有网络维护、网站维护、微机维护、摄影、摄像等……多样工作。经过一年的努力（两年的相关工作经验），看完了一尺多高的教材和辅导（十几斤重，7000到8000页），才总算快要拿到0MCP+MCDBA+MCSA+MCSE，但经我这一年多的观察，不知别的地方如何，陕西的MCSE+MCDBA已经彻底的混乱和贬值崩溃了，前些日子《西安商报》一文章竞然不负责任的报道：有一个高中生在一个暑假考完了MCP+MCSE+MCDBA+MCSD！！！如此吹牛！ 
　　我感觉，就是一个过了大学英语四级的学生也不一定能真正读懂MCSE课程中的英语！！！特别是像219这门，更何况是一个高中生！！！他敢站出来和大家说他不是100%的PAPER？可见陕西的MCSE烂到如何程度！！！如此多的100%通过的培训中心，以及到处都有的BIBLE？试问这样了MCSE值几个钱？别的地方我不知道，在陕西，MCSE不代表什么，比个国家二级强不了多少！在陕西，一个100%单纯PAPER的MCSE也就值个250（开个玩笑，比如那个《西安商报》上报道的用了一个月考完MCSE+MCDBA+MCSEA+MCSD的。要在一个月看完二三十斤重、厚达二尺多，近万页的书，佩服！！！！！）如果是靠自己努力考出来的，应该值个1000-3000的。 
　　大概谈一下我的考试情况： 
　　我的考试顺序是：先215（215的一些试题为win网络的主题，所以建议215，210,216,217连续考，间隔不要超过一个月，巩固概念，逐步加强，复习217时，会有50％以上的216的内容。第一科是实践科目，熟悉考试环境，培养考试心态都是在这一科完成的，而且对以后的士气很有用，必须一次性通过。）219是综合科目，在看完全部材料的情况下，最后考219，轻松完成mcse认证之旅！后210、216、217、218、228、229、219这样的考试可以拿MCP、MCSA、MCDBA这个证书比MCSE有用，当然如果你从事数据库方面的开发，维护的话。感觉在国内做大型分布式网络，仅仅是个mcse还是不够的，因为windows在这样的网络里只有充当client的分，但是在中小型数据库应用程序，sqlserver绝对是首选。你只要有这个证书就可以找一份很好的工作了（例如中小型管理软件的维护）特别说明，216适宜在学完210和215以后充分准备再去应考，否则除非你是使用微软产品的高手中的高手，不然十有八九会挂掉；70-216课程主要是测试运行和管理微软Windows2000网络基本构造，比基础（210）和服务器（215）的考核都难得多。如果你已经通过了210和215和考试，就已有了大量对Windows 2000网络亲身操作经验，当然，大多数的人还是要集中精力进行大量的重点学习和实验室的实际工作来达到熟练掌握以达到考核水平。网络基础考核的内容包括对Windows2000网络服务器的深入了解以及它的运作原理：DHCP, WINS, DNS IPSEC CA和RRAS等是贯穿整个考试的中心内容。同时也需要了解实际子网的运作方式。你要看一些配置网络协议安全和认证服务器的资料。然而 ，由于你掌握了专业和服务器的内容，所以能够理解Windows 2000操作系统的细节，明白Windows 2000网络服务器功能的基本知识。 
　　 对于大多数人来说，这门课程是考取MCSE、MCDBA、MCSA最难通过的一门，所以你要慎之又慎，我用的教材是MOC教材，感觉MOC教材一向高就高在是“授人以渔，而非鱼”，但要想顺利通过216的考试，光看这几本书还不够，可以参考清华出版的与MOC相配套的精解练习以及Training Kit等

　【IT专家网独家】区分数据库管理工作的一个有效方法是按照其对应用系统支持工作的类型来划分。我们可以列出DBA的职责，然后用一条线将不同的职能分开，根据区分开的职能，DBA可以被分为二种：支持开发工作的DBA和支持产品系统的DBA。

　　开发DBA们对整个应用开发的生命周期提供支持。因为这些应用的数据库没有开始运行，所以这类DBA的工作对业务不会产生即时的影响。开发DBA致力于构建一个高效、可用的数据库环境并以此来支持业务应用。当程序和系统构建的时候，开发DBA对整个过程提供支持和辅助工作，包括构建和维护应用程序所需要的适当数据结构。

　　开发DBA们需要数据模型和规范化方面的技能，以保证设计出来的数据库符合数据完整性。开发DBA还必须能够将逻辑数据模型转换成物理数据库实现的能力。

　　一旦测试数据库被创建，开发DBA们将辅助程序员构建和编辑测试数据。测试数据的生产、编辑，载入都必须经过一定的处理，以保证这些数据对构建的应用程序是适合并有效的。开发DBA还需要给团队提供工具，以方便数据库测试和数据的更新。他或她需要和整个开发团队一起工作，以确保用正确的方法访问数据库以及应用程序中应用逻辑的修改。最终，开发DBA需要和开发团队一起工作，创建并维护高效的数据库相关逻辑-存储过程、触发器和用户自定义函数，这些都是数据库管理系统控制下的程序。开发DBA将帮组构建，测试和维护这些存储过程、触发器和用户自定义函数。

　　对比之下，产品DBA的工作是基于已完成的应用系统，对正在运行中的业务系统提供支持。产品DBA致力于确保可行性，优化性能，维护可用性。一旦数据库应用系统开始运行，关键的工作就变成了如何确保它们持续稳定的运行。这可以归结为PAR，PAR是三个单词的首字母缩写：性能(performance),管理(administration)和恢复(recovery)。这三项功能，是产品DBA们在维护数据库系统过程中的三项最主要工作。

　　数据库性能管理是通过资源使用的优化，增加利用率并减少资源争夺，最终实现尽可能多的处理更多的业务。性能需要从IT基层结构开始管理。数据库管理和运行有一些日常业务可以参照：包括变化管理，数据库结构的检查，安全和权限控制等任务。备份和恢复需要在特定的时间对适当的数据库进行适当的备份，以确保其可恢复到以前的状态。当产品DBA按照PAR工作的时候，应用程序就会根据设定的服务级别来运行，数据库将在最佳的设计和良好的状态下被管理，数据也能够有效的备份，在出错或者宕机的时候可以恢复。

　　综上所述，很多时候，为了创建一个良好的数据库应用系统，我们需要定义、计划和训练开发DBA和产品DBA这两种角色。

 

　　　微软认证数据库管理员资格考试是数据库专业人员展示自己的SQL Server专业技能水平的一个机会。如果你想要向雇主证明自己的能力，或者希望在事业的阶梯上更向上攀爬，又或者仅仅是想要获得一张好看的证书给自家的墙壁稍作点缀，MCDBA(微软数据库管理员认证)资格都可以满足你的欲望……

　　【IT专家网独家】微软数据库管理员认证

　　微软认证数据库管理员资格考试是数据库专业人员展示自己的SQL Server专业技能水平的一个机会。如果你想要向雇主证明自己的能力，或者希望在事业的阶梯上更向上攀爬，又或者仅仅是想要获得一张好看的证书给自家的墙壁稍作点缀，MCDBA(微软数据库管理员认证)资格都可以满足你的欲望。

　　要通过MCDBA认证，你需要通过三门核心考试和一门可选考试。跟微软其他大部分的认证项目一样，MCDBA考试可以参加当前最新版本的SQL Server或者是马上要退居二线的版本的考试。但是，最好当然是考现有的最新版本的SQL Server，这样才可以让资格证书“保鲜期”尽可能长一点。

　　核心考试I：SQL Server管理。

　　微软目前针对SQL Server 2000只提供70-228考试。

　　这门考试主旨在于测试考生对于数据库管理和解决数据库管理相关问题的能力。如果你觉得自己已经胸有成竹了，可以试一下70-228 Practice Exam。如果你觉得还需要再准备一下，那么可以尝试一下Transcender practice tests。这些测试跟真题非常相似。

　　核心考试II：SQL Server设计。

　　考生需要通过70-229考试，主要是测试考试成功设计并执行SQL Server数据库方案的能力。

　　核心考试III：网络系统。要达到这个要求，可以选择通过以下三门考试中任何一门。首先是70-215考试，这门考试主要测试考生安装、配置和执行管理Microsoft Windows 2000 Server的能力。如果你使用的是Windows 2003，你可以选择通过测试管理和维护Microsoft Windows Server 2003环境的70-290考试，或者测试安装、配置和执行管理Microsoft Windows 2003 Server网络基础结构的70-291考试。

　　可选考试。考生可以从下面的考试中选出自己需要的MCDBA考试。这些考试覆盖面广，包含了许多应用程序开发技术、数据入库技巧和网络设计基础知识。目前可供选择的考试包括：

　　70-216考试：执行和管理Microsoft Windows 2000 网络基础结构

　　70-293考试：策划和维护Microsoft Windows 2003 网络基础结构

　　70-528考试：Microsoft NET Framework 2.0 — 网络系统客户开发

　　70-526考试：Microsoft .NET Framework 2.0 — 桌面系统客户开发

　　70-529考试：Microsoft .NET Framework 2.0 — 分布式应用系统开发

　　70-305考试：运用Microsoft Visual Basic .NET 和Microsoft Visual Studio .NET 开发和执行Web应用系统

　　70-306考试：运用Microsoft Visual Basic .NET和Microsoft Visual Studio .NET开发和执行桌面应用系统

　　70-310考试：运用Microsoft Visual Basic .NET和Microsoft .NET Framework 开发XML Web Services 和Server Components

　　70-315考试：运用Microsoft Visual C# .NET和Microsoft Visual Studio .NET开发和执行Web应用系统

　　70-316考试：运用Microsoft Visual C# .NET和Microsoft Visual Studio .NET开发和执行桌面应用系统

　　70-320考试：运用Microsoft Visual C# 和Microsoft .NET Framework开发XML Web Services和Server 组件

　　一定要注意的是MCDBA考试跟其他微软认证考试有一定的重叠，包括Microsoft认证系统管理员(MCSA)、Microsoft认证系统工程师(MCSE)和Microsoft认证解决方案开发专家(MCSD)。如果你正在考虑以后要通过以上认证，你就应该认真地考虑如何选择你的MCDBA考试了。因为通过的同一门考试可以作为多个认证的资格考试，认真挑选你要通过的考试可以既省钱也省时间。

详细讲解SQL Server系统数据库的工作原理

发布时间：2007.12.11 04:44     来源：赛迪网    作者：93263

我们知道，DBA对SQL数据库引擎的系统数据库必须有深入的了解，同时，数据库开发人员了解SQL Server自带的系统数据库也是十分有必要的。下文中列举了其中的一些系统数据库。 Master Master数据库保存有放在SQLSERVER实体上的所有数据库，它还是将引擎固定起来的粘合剂。由于如果不使用主数据库，SQLSERVER就不能启动，所以你必须要小心地管理好这个数据库。因此，对这个数据库进行常规备份是十分必要的。 这个数据库包括了诸如系统登录、配置设置、已连接的SERVER等信息，以及用于该实体的其他系统和用户数据库的一般信息。主数据库还存有扩展存储过程，它能够访问外部进程，从而让你能够与磁盘子系统和系统API调用等特性交互。这些过程一般都用像C++这样的现代编程语言。 如果不幸碰到系统崩溃而必须恢复主数据库的情况，你可以参看MCSE／MCDBA Steven Warren在TechRepublic上发表的文章。这篇文章讲得十分透彻，它解释了恢复这一重要数据库所需要的一些特殊步骤。 Model Model是一个用来在实体上创建新用户数据库的模版数据库。你可以把任何存储过程、视图、用户等放在模型数据库里，这样在创建新数据库的时候，新数据库就会包含你放在模型数据库里的所有对象了。 Tempdb 正如其名字所提示的，tempdb存有临时对象，例如全局和本地临时表格和存储过程。 这个数据库在SQLSERVER每次重启的时候都会被重新创建，而其中包含的对象是依据模型数据库里定义的对象被创建的。除了这些对象，tempdb还存有其他对象，例如表格变量、来自表格值函数的结果集，以及临时表格变量。由于tempdb会保留SQLSERVER实体上所有数据库的这些对象类型，所以对数据库进行优化配置是非常重要的。 在SQL Server 2005里，tempdb数据库还有一项额外的任务；它还被用作一些特性的版本库，例如新的快照隔离层和在线索引操作等。关于新的隔离层的简要说明，请参考我关于SQL Server 2005高级特性的文章。 Distribution 当你的SQLSERVER实体被配置为复制分发SERVER时，这个数据库就会被添加到你的系统里。在默认情况下，数据库的名字就是distribution，但是你可以更改它的名字。这个数据库用来保存历史和快照、合并和事务复制等的元数据。 Msdb Msdb数据库用来保存于数据库备份、SQL Agent信息、DTS程序包、SQLSERVER任务等信息，以及诸如日志转移这样的复制信息。 注释：随着工作或学习的深入，你会逐渐发现理解SQL Server的最佳方法是研究系统数据库的工作原理。作为一条普遍的规律，我们通常不建议大家直接在SQL Server里查询系统表格,但是通过研究这些系统数据库里的表格，大家可以学到很多有关SQL Server工作原理的实用知识。

IT业最受欢迎的认证分别是：微软认证系统管理员(MCSA)、甲骨文(Oracle)认证专家数据库管理员——(OCPDABA)、思科(Cisco)认证网络工程师(CCNA)、思科认证网络专家(CCNP)、微软认证数据库管理员(MCDBA)、Red Hat认证工程师(RHCE)、Network+、Crtrix认证管理员(CCA)、Sun Java认证软件工程师(SCJP)、信息系统安全认证专家(CISSP)。

大多企业偏爱IT认证

目前正在推动内部e化的传统企业或是一般中小企业，对于懂得网络架构，能进行网络规划、建立、维护及支持等工作，也就是为公司提供解决方案的MIS人员需求较大。

随着微软近年市场占有率提升，通过微软系统的MCSE认证，似乎可以在敲门应征时，让初次见面的应试主管，对自己在网络管理规划的专业能力有一定的认识。认证的价值等于通行证，代表你有基本的能力，可是决定录用与否，或薪资与位阶的调整，还是取决于工作经验。

名企多以工作经验为标准

一些大型外资、民营企业，对于证书的态度趋于保守。菲利普莫里斯公司的一位人力资源经理认为，因为大企业的制度比较完备，面试流程、录用的标准都有一定的程序，通常手持证书的应聘者，或许在众多具有相同资历的人会比较突出，不过还是得经过公司内部的考核。考试通过后，部门主管会针对个人面试，因此，证书只是“附加值”，但绝不是“必备品”，重要的是你到底有多少经验，口袋里藏有几把刷子？

以生产杀毒软件著称的瑞星公司，人力资源总监张晓江曾说：他们非常愿意不拘一格聘用有真才实学的“偏才、怪才”，而不在乎他们是否有专业证书。对于那些没有足够工作经验的“证书收藏家”来说，恐怕只能打道回府了。