新浪网网站的建设费用预算,ui设计网课,瑞丽市建设局网站,wordpress help sheet类的保留字#xff1a;class、struct 或 union 可用来声明和定义类。类的声明由保留字class、struct或union加上类的名称构成。类的定义包括类的声明部分和类的由{}括起来的主体两部分构成。类的实现通常指类的函数成员的实现#xff0c;即定义类的函数成员。
class 类名;//…类的保留字class、struct 或 union 可用来声明和定义类。类的声明由保留字class、struct或union加上类的名称构成。类的定义包括类的声明部分和类的由{}括起来的主体两部分构成。类的实现通常指类的函数成员的实现即定义类的函数成员。
class 类名;//前向声明
class 类名 {
private:私有成员声明或定义;
protected:保护成员声明或定义;
public:公有成员声明或定义;
};
定义类时应注意的问题 使用private、protected和public保留字标识主体中每一区间的访问权限同一保留字可以多次出现同一区间内可以有数据成员、函数成员和类型成员习惯上按类型成员、数据成员和函数成员分开成员在类定义体中出现的顺序可以任意函数成员的实现既可以放在类的外面也可以内嵌在类定义体中但是数据成员的定义顺序与初始化顺序有关。若函数成员在类定义体外实现则在函数返回类型和函数名之间应使用类名和作用域运算符“::”来指明该函数成员所属的类。在类定义体中允许对所数据成员定义默认值若在构造函数的“”和函数体的“{ ”之间对其进行了初始化则默认值无效否则用默认值初始化类定义体的最后一个花括号后要跟有分号作为定义体结束标志。构造函数和析构函数都不能定义返回类型。如果类没有自定义的构造函数和析构函数且有非公开实例数据成员等情形则C为类生成默认的无参构造函数和析构函数。构造函数的参数表可以出现参数因此可以重载。构造函数和析构函数是类封装的两个特殊函数成员都有固定类型的隐含参数this 。构造函数函数名和类名相同的函数成员。析构函数函数名和类名相同且带波浪线的参数表无参函数成员。定义变量或其生命期开始时自动调用构造函数生命期结束时自动调用析构函数。同一个对象仅自动构造一次。构造函数是唯一不能被显式人工调用的函数成员。构造函数用来为对象申请各种资源并初始化对象的数据成员。构造函数有隐含参数this, 可以在参数表定义若干参数用于初始化数据成员。析构函数是用来毁灭对象的析构过程是构造过程的逆过程。析构函数释放对象申请的所有资源。析构函数既能被显式调用也能被隐式自动调用。由于只有一个固定类型的this故不可能重载只能有一个析构函数。若实例数据成员有指针应当防止反复析构用指针是否为空做标志。联合也是类可定义构造、析构以及其它函数成员。 e.g.
#include alloc.h
struct STRING {typedef char* CHARPTR; //定义类型成员CHARPTR s; //定义数据成员int strlen(); //声明函数成员求谁的长(有this)STRING(const char*); //声明构造函数有this~STRING(); //声明析构函数有this
};
int STRING::strlen() { //用运算符::在类体外定义int k;for (k 0; s[k] ! 0; k);return k;
}
STRING::STRING(char* t) {//用::在类体外定义构造函数,无返回类型int k;for (k 0; t[k] ! 0; k);s (char*)malloc(k 1); //s等价于this-sfor (k 0; (s[k] t[k]) ! 0; k);
}
STRING::~STRING() {//用::在类体外定义析构函数,无返回类型free(s);
}
struct STRING x(simple); //struct可以省略
void main() {STRING y(complex), * z y;int m y.strlen(); //当前对象包含的字符串的长度 m z-strlen();
} //返回时自动调用y的析构函数
程序不同结束形式对对象的影响
exit 退出局部自动对象不能自动执行析构函数故此类对象资源不能被释放。静态和全局对象在exit退出main时自动执行收工函数析构。abort 退出所有对象自动调用的析构函数都不能执行。局部和全局对象的资源都不能被释放即abort退出main后不执行收工函数。return 返回隐式调用的析构函数得以执行。局部和全局对象的资源被释放。int main() { …; if (error) return 1; …; } 提倡使用 return。如果用 abort和 exit则要显式调用析构函数。另外使用异常处理时自动调用的析构函数都会执行。
#include process.h
#include “string.cpp” //不提倡这样include因为string.cpp内有函数定义
STRING x(global); //自动调用构造函数初始化x
void main(void) {short error 0;STRING y(local); //自动调用构造函数初始化yswitch (error) {case 0: return; //正常返回时自动析构 x、ycase 1: y.~STRING(); //为防内存泄漏exit退出前必须显式析构 yexit(1);default: x.~STRING(); //为防内存泄漏abort退出前须显式析构 x、yy.~STRING();abort();}
} 接受与删除编译自动生成的函数 default 接受, delete 删除。 若类A没有定义任何构造函数则编译器会自动提供无参的构造函数 A()实际上是空操作相当于一条return语句如果A定义了任何构造函数编译器就不会自动提供无参构造函数。 不管A是否定义了构造函数A类只要没有定义带引用参数 A 的构造函数 A(const A a) 编译器会自动提供该构造函数 A(const A a)利用浅拷贝实现该构造函数。 可以利用 default、delete 强制说明接受、删除编译器提供的构造函数如 A() default、 A(const A a) delete。
//使用delete禁止构造函数以及default接受构造函数。
struct A {int x 0;A(int m) : x(m) {}A(const A a) default; //接受编译生成的拷贝构造函数A(const A )
};
void main(void) {A x(2); //正确调用程序员自定义的单参构造函数A(int)A y(x); //正确调用编译生成的拷贝构造函数A(const A )A u; //错误调用构造函数A( )编译器不提供缺省的A()因为有别的构造函数A v(); //正确声明一个函数v( )其返回类型为A
} //A v() extern A v()
成员访问权限
private私有成员本类函数成员可以访问派生类函数成员、其他类函数成员和普通函数都不能访问。protected保护成员本类和派生类的函数成员可以访问其他类函数成员和普通函数都不能访问。public公有成员任何函数均可访问。 类的友元不受这些限制可以访问类的所有成员。另外通过强制类型转换可突破访问权限的限制。 构造函数和析构函数可以定义为任何访问权限。不能访问构造函数则无法用其初始化对象。
#include iostream
class A {int x; //私有只能被本类的成员访问typedef char* POINTER1;
public: //公有能被任何函数使用int y;
protected: //保护只能被本类及继承类的成员访问int z;
public: //公有能被任何函数使用typedef char* POINTER2;A(int x, int y, int z) : x(x), y(y), z(z) {}int sum() {return x y z;}
};
void main(void) {A a(1, 2, 3);
// std::cout a.x; //错不能访问私有成员std::cout a.ystd::endl; //对
// std::cout a.z; //错不能访问保护成员std::cout a.sum(); //对char s[] abcd;
// A::POINTER1 p1 s; //错类型A::POINTER1是私有的A::POINTER2 p2 s; //对
// p2 abcd; //错abcd是const char *p2是char *p2 (char*)abcd; //对等价 p2 (A::POINTER2)abcd
} 关于常量字符串 常量字符串如“abc”、“123AB”等本质上是 const 指针char *const p 它指向一个不可修改的字符串即 const char *const p。 #includecstdio
#includeiostream
using namespace std;
int main()
{const char* const p1 abc; //等价const char *const p1(abc)std::cout abc[1] p1[0]endl;//p1 123; //错const char* p2 abc; //等价const char *p2(abc)std::cout abc[1] p2[0]endl;p2 123; //对
// char* p3 abc; //错等价 char *p3(“abc”)用1个const char指针去构造char指针char* p3 (char*)abc; //等价char *p3((char *)abc)std::cout abc[1] p3[0]endl;p3[0] 1; //编译对运行错指针可改值不可改int k 1; //等价int k(1)char s[] abc; //对等价 char s[](abc)// char* p abc; //错等价 char *p(“abc”)
} //注意构造数组和构造指针是不一样的
函数成员的内联 在类体内定义的任何函数成员都会自动内联。 在类内或类外使用inline保留字说明函数成员。 内联失败有分支类语句、定义在使用后取函数地址定义(纯)虚函数。 内联函数成员的作用域局限于当前代码文件。 匿名类函数成员只能在类体内定义(内联)。 函数局部类的函数成员只能在类体内定义(内联)某些编译器不支持局部类。
位段成员按位分配内存的数据成员 class、struct 和 union 都能定义位段成员位段类型必须是字节数少于整数类型的类型如charshortintlong long , enum实现为int简单类型相邻位段成员分配内存时,可能出现若干位段成员共处一个字节或一个位段成员跨越多个字节。因按字节编址故位段无地址。位段用法用于生产过程控制的各种开关、指示灯等布尔运算、图象处理等 new 和 delete C不必实现函数 malloc、free C必须实现运算符 new、delete。
内存分配 malloc为函数参数为值表达式 new为运算符操作数为类型表达式先底层调用malloc然后调用构造函数 用 “new 类型表达式{}” 可使分配的内存清零若“{}”中有数值可用于初始化。
内存释放 free为函数参数为指针类型值表达式直接释放内存 delete为运算符操作数为指针类型值表达式先调用析构函数然后底层调用 free。
如为简单类型(没有构造、析构函数)分配和释放内存则new和malloc、 delete和free没有区别可混合使用比如new分配的内存用free释放。无法用malloc代替new初始化, new调用的构造函数可维护多态。注意delete的新参类型应为const void* 因为它可接受任意指针实参。new 类型表达式 后接()或 {}用于初始化或构造。{}可用于数组元素类型表达式int* p new int; //等价int *p new int(0);数组形式仅第一维下标可为任意表达式其它维为常量表达式int(*q)[6][8] new int[x 20][6][8];为对象数组分配内存时必须调用参数表无参构造函数delete 指针指针指向非数组的单个实体delete p; 可能调析构函数。delete[]数组指针指针指向任意维的数组时delete[] q;如为对象数组对所有对象(元素)调用析构函数。若数组元素为简单类型则可用delete 指针代替。 #include malloc.h
#include process.h
class ARRAY { //class体的缺省访问权限为privateint* a, r, c;
public: //访问权限改为publicARRAY(int x, int y);~ARRAY();
};
ARRAY::ARRAY(int x, int y) {a new int[(r x) * (c y)]; //可用mallocint为简单类型
}
ARRAY::~ARRAY() { //a指向的简单类型int数组无析构函数if (a) { delete[] a; a 0; } //可用free(a), 也可用delete a
}
ARRAY x(3, 5); //开工函数构造收工函数析构x
void main(void) {int error 0;ARRAY y(3, 5), * p; //退出main时析构yp new ARRAY(5, 7); //不能用mallocARRAY有构造函数delete p; //不能用free否则未调用析构函数
} //退出main时y被自动析构
//程序结束时收工函数析构全局对象x this指针 this指针是一个特殊的指针它是普通函数成员隐含的第一个参数其类型是指向要调用该函数成员的对象的const指针。 当对象调用函数成员时对象的地址作为函数的第一个实参首先压栈通过这种方式将对象地址传递给隐含参数this。 构造函数和析构函数的this参数类型固定。例如A::~A()的this参数类型为 A* const this; //析构函数的this指向可写对象但this本身是只读的 注意可用* this来引用或访问调用该函数成员的普通、const或volatile对象类的静态函数成员没有隐含的this指针this指针不允许移动。
#include iostream
using namespace std;
class TREE {int value;TREE* left, * right;
public:TREE(int); //this类型: TREE * const this~TREE(); //this类型: TREE * const this析构函数不能重载const TREE* find(int) const; //this类型: const TREE * const this
};
TREE::TREE(int value) { //隐含参数this指向要构造的对象this-value value; //等价于TREE::valuevalueleft right 0; //C提倡空指针NULL用0表示
}
TREE::~TREE() { //this指向要析构的对象if (left) { delete left; left 0; }if (right) { delete right; right 0; }
}
const TREE* TREE::find(int v) const { //this指向 调用对象if (v value) return this; //this指向找到的节点if (v value) //小于时查左子树即下次递归进入时新thisleftreturn left ! 0 ? left-find(v) : 0;return right ! 0 ? right-find(v) : 0; //否则查右子树
}
TREE root(5); //收工函数将析构对象root
void main(void) {if (root.find(5)) cout Found\n;
}
构造和析构 类可能会定义只读和引用类型的非静态数据成员在使用它们之前必须初始化若无默认值该类必须定义构造函数初始化这类成员。 类A还可能定义类B类型的非静态对象成员若对象成员必须用带参数的构造函数构造则A必须定义有初始化的构造函数(自定义的类A的构造函数传递实参初试化类B的非静态对象成员缺省的无参的A()只调用无参的B())。 构造函数的初始化位置在参数表的“ : ”后所有数据成员都必须在此初始化未列出的成员用其默认值值初始化未列出且无默认值的非只读、非引用、非对象成员的值根据对象存储位置可取随机值栈段或0及nullptr值数据段。 按定义顺序初始化或构造数据成员大部分编译支持。 如未定义或生成构造函数则可以用”{}”的形式初始化。联合仅需初始化第一个成员。 对象数组的每个元素都必须初始化默认采用无参构造函数初始化。 单个参数的构造函数能自动转换单个实参值成为对象。 若类未自定义构造函数且类包含私有实例数据成员时编译会自动生成构造函数。 一旦自定义构造函数将不能接受编译生成的构造函数除非用default等接受。 用常量对象做实参总是优先调用参数为 类型的构造函数 用变量对象做实参总是优先调用参数为 类型的构造函数。
class A {int a 0; //数据成员可以在定义时初始化
public:A(int x) { a x; } //重载构造函数自动内联A() { a 0; } //重载构造函数自动内联
};
class B {const int b 1; //数据成员可以在定义时初始化int c, d, e, f; //b, d, g, h只能在构造函数体前初始化A g, h; //数据成员按定义顺序b, c, d, e, f, g, h初始化
public: //类B构造函数体前未出现h故h用A()初始化B(int y) : d(c), c(y), g(y), b(y), e(y) { //自动内联c y;f y;} //f被赋值为y
};
void main(void) {int x(5); //int x 5 等价于 int x(5)A a(x), y 5; //A y 5 等价于 A y(5)A* p new A[3]{ 1, A(2) }; //初始化的元素为 A(1), A(2), A(0)B b(7), z (7, 8); //B z(7, 8) 等价于 B z(8), 等号右边必须单值delete[] p; //防止内存泄漏new 产生的所有对象必须用 delete 释放
} //故(7, 8)为C的扩号表达式(7, 8) 8 创建对象时不调用构造函数的情况满足下面的条件
类中没有定义任何构造函数、没有虚函数该类不是派生类别的类可以是该类的派生类定义对象时用 { ... } 给对象赋值{ ... }中的元素个数必须小于等于类中实例成员变量非static变量的个数。这相当于在构造函数的参数初始化列表中给实例成员变量初始化用非空的 { ... } 给对象赋值时, 类中对应的实例成员变量可以被访问。
struct A { class A {const int a; 或者 public:int b; const int a;
}; int b;}
int main(void) {A a1 { }; //对不调用构造函数A a2 { 1 }; //对不调用构造函数A a3 { 1, 2 }; //对不调用构造函数A a4 { 1, 2, 3 }; //错需要调用带3个int参数的构造函数A a5; //错需要无参的构造函数因为 const int a
} 如果A定义为如下情况 struct A {const int a;int b;A(…) { }
}; //用 { … } 赋值也需要调用构造函数, 这时 {…}表示构造函数的参数表.
//或者
class A {const int a;int b;
}; //成员变量不可访问, 不能用 { … } 赋值.
