泰和县城乡建设局网站招标网站哪个比较好

当前位置： 首页 > news >正文

泰和县城乡建设局网站,招标网站哪个比较好,深圳高端画册设计,业务网站在线生成文章目录 C命名空间定义命名空间using指令不连续的命名空间嵌套的命名空间 面向对象类类成员的访问权限及类的封装对象类成员函数类访问修饰符构造函数和析构函数类的构造函数带参数的构造函数使用初始化列表来初始化字段类的析构函数拷贝构造函数 友元函数内联函数this指针指向… 文章目录 C命名空间定义命名空间using指令不连续的命名空间嵌套的命名空间 面向对象类类成员的访问权限及类的封装对象类成员函数类访问修饰符构造函数和析构函数类的构造函数带参数的构造函数使用初始化列表来初始化字段类的析构函数拷贝构造函数 友元函数内联函数this指针指向类的指针类的静态成员静态成员函数 继承和派生访问控制和继承继承类型多继承 重载运算符和重载函数函数重载运算符重载可重载运算符/不可重载运算符 动态内存new和delete运算符数组的动态内存分配对象的动态内存分配 C命名空间 在 C 应用程序中可能会写一个名为 xyz() 的函数在另一个可用的库中也存在一个相同的函数 xyz()。这样编译器就无法判断您所使用的是哪一个 xyz() 函数。 因此引入了命名空间这个概念专门用于解决上面的问题它可作为附加信息来区分不同库中相同名称的函数、类、变量等。使用了命名空间即定义了上下文。本质上命名空间就是定义了一个范围。 我们举一个计算机系统中的例子一个文件夹(目录)中可以包含多个文件夹每个文件夹中不能有相同的文件名但不同文件夹中的文件可以重名。
定义命名空间 命名空间的定义使用关键字 namespace后跟命名空间的名称如下所示 为了调用带有命名空间的函数或变量需要在前面加上命名空间的名称如下所示
#include iostream using namespace std;// 第一个命名空间 namespace first_space{void func(){cout Inside first_space endl;} } // 第二个命名空间 namespace second_space{void func(){cout Inside second_space endl;} } int main () {// 调用第一个命名空间中的函数first_space::func();// 调用第二个命名空间中的函数second_space::func(); return 0; }using指令 可以使用 using namespace 指令这样在使用命名空间时就可以不用在前面加上命名空间的名称。这个指令会告诉编译器后续的代码将使用指定的命名空间中的名称。 #include iostream using namespace std;// 第一个命名空间 namespace first_space{void func(){cout Inside first_space endl;} } // 第二个命名空间 namespace second_space{void func(){cout Inside second_space endl;} } using namespace first_space; int main () {// 调用第一个命名空间中的函数func();return 0; }using 指令也可以用来指定命名空间中的特定项目。例如如果只打算使用 std 命名空间中的 cout 部分您可以使用如下的语句 随后的代码中在使用 cout 时就可以不用加上命名空间名称作为前缀但是 std 命名空间中的其他项目仍然需要加上命名空间名称作为前缀。 #include iostream using std::cout;int main () {cout std::endl is used with std! std::endl;return 0; }不连续的命名空间 命名空间可以定义在几个不同的部分中因此命名空间是由几个单独定义的部分组成的。一个命名空间的各个组成部分可以分散在多个文件中。 所以如果命名空间中的某个组成部分需要请求定义在另一个文件中的名称则仍然需要声明该名称。下面的命名空间定义可以是定义一个新的命名空间也可以是为已有的命名空间增加新的元素
嵌套的命名空间 命名空间可以嵌套您可以在一个命名空间中定义另一个命名空间如下所示 您可以通过使用 :: 运算符来访问嵌套的命名空间中的成员 在上面的语句中如果使用的是 namespace_name1那么在该范围内 namespace_name2 中的元素也是可用的如下所示 #include iostream using namespace std;// 第一个命名空间 namespace first_space{void func(){cout Inside first_space endl;}// 第二个命名空间namespace second_space{void func(){cout Inside second_space endl;}} } using namespace first_space::second_space; int main () {// 调用第二个命名空间中的函数func();return 0; }面向对象 类 类也是一种数据类型。 类的声明 成员函数的定义类内类外类外内联函数 内联函数的代码会直接嵌入到主调函数中可以节省调用时间如果成员函数在类内定义自动为内联函数。 类成员的访问权限及类的封装 和Java、C#不同的是C中public、private、protected只能修饰类的成员不能修饰类C中的类没有共有私有之分类内部没有访问权限的限制都可以互相访问。在C中用class定义的类中其成员的默认存取权限是private。
对象 注不可以在定义类的同时对其数据成员进行初始化因为类不是一个实体不合法但是能编译运行。 对象成员的引用对象名.数据成员名 或者 对象名.成员函数名(参数列表) 私有成员和受保护成员不能直接使用成员访问运算符.来访问。 范围解析运算符。 类成员函数 类的成员函数是指那些把定义和原型写在类定义内部的函数就像类定义中的其他变量一样。类成员函数是类的一个成员它可以操作类的任意对象可以访问对象中的所有成员。 成员函数可以定义在类内部或者在**类外部单独使用范围解析运算符:: **来定义。在类中定义的即使没有把函数声明为内联inline的也可以直接定义。 类内定义 类外定义 类外定义使用范围运算符::调用成员函数是使用.。 类访问修饰符 public、private、protected 称为访问修饰符用来防止函数直接访问类的内部成员通过在类主题内部对各个区域进行标记来指定访问限制。默认private。 实际操作中我们会在私有域定义数据公有域定义相关函数以便在累的外部也可以调用这些函数。 protected成员变量或函数与私有成员十分类似不同的是protected成员在派生类中是可访问的。 继承的特点 private成员只能被本类成员和友元访问不能被派生类访问。
构造函数和析构函数 类的构造是一种特殊的函数在每次创建一个新的对象时使用。类的析构函数也是一种特殊函数在删除所创建的对象时调用。 类的构造函数 构造函数的名称与类的名称是完全相同的并且不会返回任何类型也不会返回 void。构造函数可用于为某些成员变量设置初始值。 #include iostreamusing namespace std;class Line {public:void setLength( double len );double getLength( void );Line(); // 这是构造函数private:double length; };// 成员函数定义 Line::Line(void)//定义构造函数 {cout Object is being created endl; }void Line::setLength( double len ) {length len; }double Line::getLength( void ) {return length; } // 程序的主函数 int main( ) {Line line;// 设置长度line.setLength(6.0); cout Length of line : line.getLength() endl;return 0; }带参数的构造函数 默认的构造函数没有任何参数但如果需要构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值。 #include iostreamusing namespace std;class Line {public:void setLength( double len );double getLength( void );Line(double len); // 这是构造函数private:double length; };// 成员函数定义包括构造函数 Line::Line( double len) {cout Object is being created, length len endl;length len; }void Line::setLength( double len ) {length len; }double Line::getLength( void ) {return length; } // 程序的主函数 int main( ) {Line line(10.0);// 获取默认设置的长度cout Length of line : line.getLength() endl;// 再次设置长度line.setLength(6.0); cout Length of line : line.getLength() endl;return 0; }使用初始化列表来初始化字段 使用初始化列表来初始化字段 Line::Line( double len): length(len) {cout Object is being created, length len endl; }等同于如下语法 Line::Line( double len) {length len;cout Object is being created, length len endl; }假设有一个类 C具有多个字段 X、Y、Z 等需要进行初始化同理地您可以使用上面的语法只需要在不同的字段使用逗号进行分隔。 C::C( double a, double b, double c): X(a), Y(b), Z© {…. }类的析构函数 析构函数的名称与类的名称是完全相同的只是在前面加了个波浪号~作为前缀它不会返回任何值也不能带有任何参数。析构函数有助于在跳出程序比如关闭文件、释放内存等前释放资源。 #include iostreamusing namespace std;class Line {public:void setLength( double len );double getLength( void );Line(); // 这是构造函数声明~Line(); // 这是析构函数声明private:double length; };// 成员函数定义包括构造函数 Line::Line(void) {cout Object is being created endl; } Line::~Line(void) {cout Object is being deleted endl; }void Line::setLength( double len ) {length len; }double Line::getLength( void ) {return length; } // 程序的主函数 int main( ) {Line line;// 设置长度line.setLength(6.0); cout Length of line : line.getLength() endl;return 0; }拷贝构造函数 友元函数 类的友元函数是定义在类外部但有权访问类的所有私有private成员和保护protected成员。尽管友元函数的原型有在类的定义中出现过但是友元函数并不是成员函数。 友元可以是一个函数该函数被称为友元函数友元也可以是一个类该类被称为友元类在这种情况下整个类及其所有成员都是友元。 如果要声明函数为一个类的友元需要在类定义中该函数原型前使用关键字 friend如下所示 class Box {double width; public:double length;friend void printWidth( Box box );void setWidth( double wid ); };声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元需要在类 ClassOne 的定义中放置如下声明 friend class ClassTwo; #include iostreamusing namespace std;class Box {double width; public:friend void printWidth( Box box );void setWidth( double wid ); };// 成员函数定义 void Box::setWidth( double wid ) {width wid; }// 请注意printWidth() 不是任何类的成员函数 void printWidth( Box box ) {/ 因为 printWidth() 是 Box 的友元它可以直接访问该类的任何成员 */cout Width of box : box.width endl; }// 程序的主函数 int main( ) {Box box;// 使用成员函数设置宽度box.setWidth(10.0);// 使用友元函数输出宽度printWidth( box );return 0; }内联函数 C 内联函数是通常与类一起使用。如果一个函数是内联的那么在编译时编译器会把该函数的代码副本放置在每个调用该函数的地方。 对内联函数进行任何修改都需要重新编译函数的所有客户端因为编译器需要重新更换一次所有的代码否则将会继续使用旧的函数。 如果想把一个函数定义为内联函数则需要在函数名前面放置关键字 inline在调用函数之前需要对函数进行定义。如果已定义的函数多于一行编译器会忽略 inline 限定符。 在类定义中的定义的函数都是内联函数即使没有使用 inline 说明符。 #include iostreamusing namespace std;inline int Max(int x, int y) {return (x y)? x : y; }// 程序的主函数 int main( ) {cout Max (20,10): Max(20,10) endl;cout Max (0,200): Max(0,200) endl;cout Max (100,1010): Max(100,1010) endl;return 0; }this指针 在 C 中每一个对象都能通过 this指针来访问自己的地址。this指针是所有成员函数的隐含参数。因此在成员函数内部它可以用来指向调用对象。 友元函数没有this指针因为友元不是类的成员。只有成员函数才有 this 指针。 #include iostreamusing namespace std;class Box {public:// 构造函数定义Box(double l2.0, double b2.0, double h2.0){cout Constructor called. endl;length l;breadth b;height h;}double Volume(){return length * breadth * height;}int compare(Box box){return this-Volume() box.Volume();}private:double length; // Length of a boxdouble breadth; // Breadth of a boxdouble height; // Height of a box };int main(void) {Box Box1(3.3, 1.2, 1.5); // Declare box1Box Box2(8.5, 6.0, 2.0); // Declare box2if(Box1.compare(Box2)){cout Box2 is smaller than Box1 endl;}else{cout Box2 is equal to or larger than Box1 endl;}return 0; }指向类的指针 一个指向 C 类的指针与指向结构的指针类似访问指向类的指针的成员需要使用成员访问运算符 -就像访问指向结构的指针一样。与所有的指针一样您必须在使用指针之前对指针进行初始化。 #include iostreamusing namespace std;class Box {public:// 构造函数定义Box(double l2.0, double b2.0, double h2.0){cout Constructor called. endl;length l;breadth b;height h;}double Volume(){return length * breadth * height;}private:double length; // Length of a boxdouble breadth; // Breadth of a boxdouble height; // Height of a box };int main(void) {Box Box1(3.3, 1.2, 1.5); // Declare box1Box Box2(8.5, 6.0, 2.0); // Declare box2Box *ptrBox; // Declare pointer to a class.// 保存第一个对象的地址ptrBox Box1;// 现在尝试使用成员访问运算符来访问成员cout Volume of Box1: ptrBox-Volume() endl;// 保存第二个对象的地址ptrBox Box2;// 现在尝试使用成员访问运算符来访问成员cout Volume of Box2: ptrBox-Volume() endl;return 0; }类的静态成员 我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时这意味着无论创建多少个类的对象静态成员都只有一个副本。 静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句在创建第一个对象时所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化 #include iostreamusing namespace std;class Box {public:static int objectCount;// 构造函数定义Box(double l2.0, double b2.0, double h2.0){cout Constructor called. endl;length l;breadth b;height h;// 每次创建对象时增加 1objectCount;}double Volume(){return length * breadth * height;}private:double length; // 长度double breadth; // 宽度double height; // 高度 };// 初始化类 Box 的静态成员 int Box::objectCount 0;int main(void) {Box Box1(3.3, 1.2, 1.5); // 声明 box1Box Box2(8.5, 6.0, 2.0); // 声明 box2// 输出对象的总数cout Total objects: Box::objectCount endl;return 0; }静态成员函数 如果把函数成员声明为静态的就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用静态函数只要使用类名加范围解析运算符 :: 就可以访问。 静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。 静态成员函数有一个类范围他们不能访问类的 this 指针。您可以使用静态成员函数来判断类的某些对象是否已被创建。 静态成员函数与普通成员函数的区别 静态成员函数没有 this 指针只能访问静态成员包括静态成员变量和静态成员函数。普通成员函数有 this 指针可以访问类中的任意成员而静态成员函数没有 this 指针。 #include iostreamusing namespace std;class Box {public:static int objectCount;// 构造函数定义Box(double l2.0, double b2.0, double h2.0){cout Constructor called. endl;length l;breadth b;height h;// 每次创建对象时增加 1objectCount;}double Volume(){return length * breadth * height;}static int getCount(){return objectCount;}private:double length; // 长度double breadth; // 宽度double height; // 高度 };// 初始化类 Box 的静态成员 int Box::objectCount 0;int main(void) {// 在创建对象之前输出对象的总数cout Inital Stage Count: Box::getCount() endl;Box Box1(3.3, 1.2, 1.5); // 声明 box1Box Box2(8.5, 6.0, 2.0); // 声明 box2// 在创建对象之后输出对象的总数cout Final Stage Count: Box::getCount() endl;return 0; }继承和派生 一个类可以派生自多个类这意味着它可以从多个基类继承数据和函数。定义一个派生类我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名形式如下 class derived-class: access-specifier base-class 访问修饰符 access-specifier 是 public、protected 或 private 其中的一个base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier则默认为 private。 #include iostreamusing namespace std;// 基类 class Shape {public:void setWidth(int w){width w;}void setHeight(int h){height h;}protected:int width;int height; };// 派生类 class Rectangle: public Shape {public:int getArea(){ return (width * height); } };int main(void) {Rectangle Rect;Rect.setWidth(5);#调用基类的函数Rect.setHeight(7);// 输出对象的面积cout Total area: Rect.getArea() endl;# 派生类的函数return 0; }访问控制和继承 派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问则应在基类中声明为 private。 一个派生类继承了所有的基类方法但下列情况除外 基类的构造函数、析构函数和拷贝构造函数。基类的重载运算符。基类的友元函数。 继承类型 无论哪种继承方式 private成员只能被本类成员类内和友元访问不能被派生类访问protected成员可以被派生类访问。 publie继承 #includeiostream #includeassert.h using namespace std;class A{ public:int a;A(){a1 1;a2 2;a3 3;a 4;}void fun(){cout a endl; //正确cout a1 endl; //正确cout a2 endl; //正确cout a3 endl; //正确} public:int a1; protected:int a2; private:int a3; }; class B : public A{ public:int a;B(int i){A();a i;}void fun(){cout a endl; //正确public成员cout a1 endl; //正确基类的public成员在派生类中仍是public成员。cout a2 endl; //正确基类的protected成员在派生类中仍是protected可以被派生类访问。cout a3 endl; //错误基类的private成员不能被派生类访问。} }; int main(){B b(10);cout b.a endl;cout b.a1 endl; //正确cout b.a2 endl; //错误类外不能访问protected成员cout b.a3 endl; //错误类外不能访问private成员system(pause);return 0; }protected继承 #includeiostream #includeassert.h using namespace std; class A{ public:int a;A(){a1 1;a2 2;a3 3;a 4;}void fun(){cout a endl; //正确cout a1 endl; //正确cout a2 endl; //正确cout a3 endl; //正确} public:int a1; protected:int a2; private:int a3; }; class B : protected A{ public:int a;B(int i){A();a i;}void fun(){cout a endl; //正确public成员。cout a1 endl; //正确基类的public成员在派生类中变成了protected可以被派生类访问。cout a2 endl; //正确基类的protected成员在派生类中还是protected可以被派生类访问。cout a3 endl; //错误基类的private成员不能被派生类访问。} }; int main(){B b(10);cout b.a endl; //正确。public成员cout b.a1 endl; //错误protected成员不能在类外访问。cout b.a2 endl; //错误protected成员不能在类外访问。cout b.a3 endl; //错误private成员不能在类外访问。system(pause);return 0; }private继承 #includeiostream #includeassert.h using namespace std; class A{ public:int a;A(){a1 1;a2 2;a3 3;a 4;}void fun(){cout a endl; //正确cout a1 endl; //正确cout a2 endl; //正确cout a3 endl; //正确} public:int a1; protected:int a2; private:int a3; }; class B : private A{ public:int a;B(int i){A();a i;}void fun(){cout a endl; //正确public成员。cout a1 endl; //正确基类public成员,在派生类中变成了private,可以被派生类访问。cout a2 endl; //正确基类的protected成员在派生类中变成了private,可以被派生类访问。cout a3 endl; //错误基类的private成员不能被派生类访问。} }; int main(){B b(10);cout b.a endl; //正确。public成员cout b.a1 endl; //错误private成员不能在类外访问。cout b.a2 endl; //错误, private成员不能在类外访问。cout b.a3 endl; //错误private成员不能在类外访问。system(pause);return 0; }多继承 多继承即一个子类可以有多个父类它继承了多个父类的特性。 class 派生类名:继承方式1基类名1,继承方式2基类名2,… { 派生类类体 };其中访问修饰符继承方式是 public、protected 或 private 其中的一个用来修饰每个基类各个基类之间用逗号分隔如上所示。 #include iostreamusing namespace std;// 基类 Shape class Shape {public:void setWidth(int w){width w;}void setHeight(int h){height h;}protected:int width;int height; };// 基类 PaintCost class PaintCost {public:int getCost(int area){return area * 70;} };// 派生类 class Rectangle: public Shape, public PaintCost {public:int getArea(){ return (width * height); } };int main(void) {Rectangle Rect;int area;Rect.setWidth(5);Rect.setHeight(7);area Rect.getArea();// 输出对象的面积cout Total area: Rect.getArea() endl;// 输出总花费cout Total paint cost: $ Rect.getCost(area) endl;return 0; }重载运算符和重载函数 C 允许在同一作用域中的某个函数和运算符指定多个定义分别称为函数重载和运算符重载。 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明但是它们的参数列表和定义实现不相同。 当您调用一个重载函数或重载运算符时编译器通过把您所使用的参数类型与定义中的参数类型进行比较决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程称为重载决策。 函数重载 在同一个作用域内可以声明几个功能类似的同名函数但是这些同名函数的形式参数指参数的个数、类型或者顺序必须不同这就是函数重载。不能仅通过返回类型的不同来重载函数。 #include iostream using namespace std;class printData {public:void print(int i) {cout 整数为: i endl;}void print(double f) {cout 浮点数为: f endl;}void print(char c[]) {cout 字符串为: c endl;} };int main(void) {printData pd;// 输出整数pd.print(5);// 输出浮点数pd.print(500.263);// 输出字符串char c[] Hello C;pd.print©;return 0; }运算符重载 可以重定义或重载大部分 C 内置的运算符。这样您就能使用自定义类型的运算符。 重载的运算符是带有特殊名称的函数函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样重载运算符有一个返回类型和一个参数列表。 Box operator(const Box); 声明加法运算符用于把两个 Box 对象相加返回最终的 Box 对象。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。如果我们定义上面的函数为类的非成员函数那么我们需要为每次操作传递两个参数。 Box operator(const Box, const Box); 下面实例使用成员函数演示了运算符重载的概念例子中对象作为参数进行传递对象的属性使用this运算符进行访问。 #include iostream using namespace std;class Box {public:double getVolume(void){return length * breadth * height;}void setLength( double len ){length len;}void setBreadth( double bre ){breadth bre;}void setHeight( double hei ){height hei;}// 重载 运算符用于把两个 Box 对象相加Box operator(const Box b){Box box;box.length this-length b.length;box.breadth this-breadth b.breadth;box.height this-height b.height;return box;}private:double length; // 长度double breadth; // 宽度double height; // 高度 }; // 程序的主函数 int main( ) {Box Box1; // 声明 Box1类型为 BoxBox Box2; // 声明 Box2类型为 BoxBox Box3; // 声明 Box3类型为 Boxdouble volume 0.0; // 把体积存储在该变量中// Box1 详述Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0);// Box2 详述Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0);// Box1 的体积volume Box1.getVolume();cout Volume of Box1 : volume endl;// Box2 的体积volume Box2.getVolume();cout Volume of Box2 : volume endl;// 把两个对象相加得到 Box3Box3 Box1 Box2;// Box3 的体积volume Box3.getVolume();cout Volume of Box3 : volume endl;return 0; }可重载运算符/不可重载运算符 动态内存 了解动态内存在 C 中是如何工作的是成为一名合格的 C 程序员必不可少的。C 程序中的内存分为两个部分 栈在函数内部声明的所有变量都将占用栈内存。堆这是程序中未使用的内存在程序运行时可用于动态分配内存。 很多时候您无法提前预知需要多少内存来存储某个定义变量中的特定信息所需内存的大小需要在运行时才能确定。 在 C 中您可以使用特殊的运算符为给定类型的变量在运行时分配堆内的内存这会返回所分配的空间地址。这种运算符即 new 运算符。 如果您不再需要动态分配的内存空间可以使用 delete 运算符删除之前由 new 运算符分配的内存。 new和delete运算符 使用new运算符来为任意的数据类型动态分配内存的通用语法 new data-type data-type可以是包括数组在内的任意内置的数据类型也可以是包括类或结构在内的用户自定义的任何数据类型。 例如定义一个指向 double 类型的指针然后请求内存该内存在执行时被分配。 double* pvalue NULL; // 初始化为 null 的指针 pvalue new double; // 为变量请求内存如果自由存储区已被用完可能无法成功分配内存。所以建议检查 new 运算符是否返回 NULL 指针并采取以下适当的操作 double* pvalue NULL; if( !(pvalue new double )) {cout Error: out of memory. endl;exit(1); }malloc() 函数在 C 语言中就出现了在 C 中仍然存在但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比其主要的优点是new 不只是分配了内存它还创建了对象。 在任何时候当您觉得某个已经动态分配内存的变量不再需要使用时您可以使用 delete 操作符释放它所占用的内存如下所示 delete pvalue; //释放pvalue所指向的内存如下实例展示了如何使用new和delete运算符 #include iostream using namespace std;int main () {double* pvalue NULL; // 初始化为 null 的指针pvalue new double; // 为变量请求内存*pvalue 29494.99; // 在分配的地址存储值cout Value of pvalue : pvalue endl;delete pvalue; // 释放内存return 0; }数组的动态内存分配 假设我们要为一个字符数组一个有 20 个字符的字符串分配内存我们可以使用上面实例中的语法来为数组动态地分配内存如下所示 char pvalue NULL; // 初始化为 null 的指针 pvalue new char[20]; // 为变量请求内存删除刚才创建的数组 delete [] pvalue; // 删除 pvalue 所指向的数组可以为多多维数组分配内存 一维数组 // 动态分配,数组长度为 m int *arraynew int [m];//释放内存 delete [] array;二维数组 int **array; // 假定数组第一维长度为 m 第二维长度为 n // 动态分配空间 array new int *[m]; for( int i0; im; i ) {array[i] new int [n]; } //释放 for( int i0; im; i ) {delete [] array[i]; } delete [] array;实例 #include iostream using namespace std;int main() {int **p; int i,j; //p[4][8] //开始分配4行8列的二维数据 p new int *[4];for(i0;i4;i){p[i]new int [8];}for(i0; i4; i){for(j0; j8; j){p[i][j] ji;}} //打印数据 for(i0; i4; i){for(j0; j8; j) { if(j0) coutendl; coutp[i][j]\t; }} //开始释放申请的堆 for(i0; i4; i){delete [] p[i]; }delete [] p; return 0; }对象的动态内存分配 对象与简单的数据类型没有什么不同。 #include iostream using namespace std;class Box {public:Box() { cout 调用构造函数 endl; }~Box() { cout 调用析构函数 endl; } };int main( ) {Box myBoxArray new Box[4];delete [] myBoxArray; // 删除数组return 0; }如果要为一个包含四个 Box 对象的数组分配内存构造函数将被调用 4 次同样地当删除这些对象时析构函数也将被调用相同的次数4次。
参考链接菜鸟教程C