符号常量

符号常量●使用修饰符const●使用enum关键词定义一组整数常量如果只使用const修饰符，变量将自动转为int整型。

比如：const size = 10;意为const int size = 10;除了不可改变值外，命名后的常量和变量一样。

C++中，变量必须初始化。

而在标准C中，常量不必初始化，如没有初始化，常量默认为0；C和C++中，const变量的作用域也不同。

C++中，常量默认为内部链接，所以在其声明的文件内可见。

在标准C中，常量就是全局变量。

它们在声明文件之外都可见。

不过，加上static声明后，标准C中的常量也可变成局部可见。

而在C++中，为了使某个常量链接到外部，以便能被另外的文件访问，我们需要显示地在常量定义前面加extern关键词。

如下：extern const total = 100;另一个命名整数常量的方法是使用枚举类型，如下所示：enum {X, Y, Z};此句定义了X、Y和Z三个整型变量，值分别为0,1,2。

该语句等价于下列语句：const X = 0;const Y = 0;const Z = 0;我们也可显式地赋值X，Y，Z，如下：enum {X = 100, Y = 50, Z = 200};可赋予任何整数值。

常量指针与指针常量C++中添加了指针常量和常量指针。

char* const ptr1 = “GooD”; //指针常量我们不能修改ptr1指向的地址。

int const * ptr2 = &m; //常量指针ptr2声明为常量指针，它可以指向任何正确类型的变量，但指向的值不可改变。

我们也可以同时将指针和变量声明为常量，如下所示：const char * const cp = “xyz”;该语句声明cp为指针常量，并指向一个声明为常量的字符串。

这种情况下，赋予指针cp的地址和指针指向的值都不能更改。

成员指针我们可以取类成员的地址，并将其赋值给同一个指针。

对于一个完全修饰的类成员名，我们可对其应用操作符&，来获得成员的地址。

声明一个类成员指针时，可使用类名和操作符::*。

比如，给定下列类class A{private:int m;public:void show();};我们可以如下定义成员m的指针：int A::* ip = &A::m;指针ip被创建后，就如同类的成员一样，必须使用类对象才能调用。

在上述语句中，A::*意为“指向类A的成员的指针”，而&A::m意为“类A的成员的地址”。

记住，下列的用法是不合法的。

int* ip = &m; //不合法这是因为m不是一个简单的整型数。

只有和属于的类相关时，它才有意义。

所以对于这种指针和和成员，必须使用作用域操作符。

在成员函数内（或者友元函数内），指针ip可用于访问成员m。

假定a是在成员函数内声明的A类对象，我们可按如下方法，用指针ip访问m。

cout << a.*ip; //显示cout << a.m; //和上行一样现在，看一下下面的代码ap = &a; //ap是对象a的指针cout << ap->*ip; //显示mcout << ap->m; //和上行一样当使用对象和成员的指针时，我们用取值符->*来访问成员。

当在对象中使用了成员指针时，则用取值符.*。

注意到*ip的用法形同成员名。

我们也可以设计成员函数的指针，在main()函数中，可用取值符调用指针指向的函数，如下所以：(object - name.*pointer - to - member function)(10); (pointer - to - object->*pointer - to - member function)(10);（）的优先级要高于.*和->*,所以括号是必要的。

程序案例：#include<iostream>using namespace std;class M{private:int x;int y;public:void setValue(int a, int b){x = a;y = b;}friend int sum(M m);};int sum(M m){int M::* px = &M::x; //格式1int M::* py = &M::y;M* pm = &m;int S = m.*px + pm->*py; //格式2return S;}int main(int argc, char* argv[]){M n;void(M::*pf)(int, int) = &M::setValue; //格式3 (n.*pf)(10, 20);cout << "sum = " << sum(n) << endl;M* op = &n;(op->*pf)(30, 40);cout << "sum = " << sum(n) << endl;system("pause");return 0;}带参构造函数#include<iostream>using namespace std;class Integer{private:int m, n;public:Integer(int x, int y);void display(void);};Integer::Integer(int x, int y){m = x;n = y;}void Integer::display(void){cout << "m = " << m << endl;cout << "n = " << n << endl;}int main(int argc, char* argv[]){//Integer intg1; //不存在构造函数，所以不能使用Integer intg2 = Integer(25, 75);Integer intg3(0, 100);cout << "\nOBJECT2" << endl;intg2.display();cout << "\nOBJECT3" << endl;intg3.display();system("pause");return 0;}构建二维数组我们可以使用类变量，来构建矩阵变量。

案例程序：#include<iostream>using namespace std;class Matrix{private:int** p; //矩阵的指针int d1, d2; //维度public:Matrix(int x, int y);~Matrix(); //析构函数void getElement(int i, int j, int value) {p[i][j] = value;}int& putElement(int i, int j){return p[i][j];}};Matrix::Matrix(int x, int y){d1 = x;d2 = y;p = new int*[d1]; //创建指针数组for (int i = 0; i < d1; i++){p[i] = new int[d2]; //为每一行分配内存}}Matrix::~Matrix(){for (int i = 0; i < d1; i++){delete p[i];delete p;}}int main(){int m, n;cout << "Enter size of matrix: ";cin >> m >> n;Matrix A(m, n); //创建矩阵对象Acout << "Enter matrix element row by row." << endl;int i, j, value;for (i = 0; i < m; i++){for (j = 0; j < n; j++){cin >> value;A.getElement(i, j, value);}}cout << endl;cout << A.putElement(1, 2);system("pause");return 0;}常量对象我们也可以创建和使用常量对象，只要在对象声明前加上const关键词。

比如，在下面的声明中，我们创建了Matrix类的一个常量对象：const Matrix X(m,n); //对象X是常量任何修改m和n值的企图都会造成编译错误。

另外，常量对象只能调用其常量成员函数。

正如我们已知道的，常量成员是一种函数原型或函数定义，其中关键词const出现在函数的签名中。

当常量对象试图调用非常量成员函数时，也会产生编译错误。

类到基本类型的转换C++允许我们重载类型转换符，它可用于将类变量转换成基本类型。

重载类型转换符函数（通常指转换函数）的一般形式如下：operator typename(){..........(函数语句)..........}比如下面的转换函数：vector::operato r double(){double sum = 0;for (int i = 0; i < size; i++)sum = sum + v[i] * v[i];return sqrt(sum);}double length = double(V1);double length = V1; //V1是vector类型的对象转换符函数应符合下列条件：●必须有类名●必须不指定返回类型●必须没有任何参数数据类型转换类型的例子案例：#include<iostream>using namespace std;class Invent1{private:int code;int items;float price;public:Invent1(int a, int b, float c)code = a;items = b;price = c;}void getData(void){cout << "Code = " << code << endl;cout << "Items = " << items << endl;cout << "Value = " << price << endl;}int getCode(){return code;}int getItems(){return items;}float getPrice(){return price;}operator float() //类Invent1向float类型的转换{return (items*price);}};class Invent2{private:int code;float value;public:Invent2(){code = 0;value = 0;Invent2(int x, int y){code = x;value = float(y);}void getData(){cout << "Code = " << code << endl;cout << "Value = " << value << endl;}/*类Invent1 到类Invent2*/Invent2(Invent1p){code = p.getCode();value = p.getItems()*p.getPrice();}};int main(){Invent1 s1 = Invent1(100, 5, 140.0);Invent2 d1;float totalValue;/*类Invent1 到 float类型*/totalValue = s1;/*类Invent1 到类Invent2*/d1 = s1;cout << "Product details -Invent1 type" << endl;s1.getData();cout << endl << "stock value" << endl;cout << "Value = " << totalValue << endl << endl;cout << "Product details-Invent2 type" << endl;d1.getData();system("pause");return 0;}派生类成员的访问属性基类成员在派生类中的访问属性（综合）解决继承中的歧义多继承：#include<iostream>using namespace std;class M{public:void display(void){cout << "Class M" << endl;}};class N{public:void display(void){cout << "Class N" << endl;}};class P :public M, public N{public:void display(void){M::display(); //解决方案}};单继承：#include<iostream>using namespace std;class A{public:void display(){cout << "A" << endl;}};class B :public A{public:void display(){cout << "B" << endl;}};int main(){B b;b.display(); //重点在这里b.A::display(); //加上::b.B::display(); //加上::return 0;}混合继承案例：//ClassInfo.hclass Student{protected:int rollNumber;public:void getNumber(int a);void putNumber(void);};class test :public Student{protected:float part1;float part2;public:void getMarks(float x, float y);void putMarks(void);};class Sports{protected:float score;public:void getScore(float a);void putScore(void);};class result :public test, public Sports {private:float total;public:void display(void);};//ClassInfo.cpp#include<iostream>#include"ClassInfo.h"using namespace std;void Student::getNumber(int a){rollNumber = a;}void Student::putNumber(void){cout << "Roll No: " << rollNumber << endl; }void test::getMarks(float x, float y){part1 = x;part2 = y;}void test::putMarks(void){cout << "Marks obtained : " << endl;cout << "part1 = " << part1 << endl;cout << "part2 = " << part2 << endl;}void Sports::getScore(float a){score = a;}void Sports::putScore(void){cout << "Sports wt: " << score << endl;}void result::display(void){total = part1 + part2 + score;putNumber();putMarks();putScore();cout << "Total score: " << total << endl; }#include"ClassInfo.h"#include<iostream>using namespace std;int main(){result stu;stu.getNumber(1234);stu.getMarks(27.5, 33.0);stu.getScore(6.0);stu.display();system("pause");return 0;}虚基类在声明直接或间接基类时，通过将通用基类（祖先类）设为虚基类，就可以避免多路继承引起的成员重复。