C++学习笔记七

23、(1).常指针
char *const ptr1 = strptrl;
>ptrl是一个常量指针，指向固定的地方。
>ptrl = strptr2; 错误
>*ptrl = "m";    正确
>ptr不可以更新
>ptr所指向的变量可以更新；


const char *ptr2 = strptrl;
>ptrl是一个指向常量的指针；
>ptrl = strptr2;  正确
>*ptrl = strptr2; 错误
>ptr2所指向的字符串不可以改变

#include<iostream.h>
const int N = 6;
void print(const int *p,int n);
void main()
{
int array[N],i;
for(i = 0;i < 6;i++)
cin>>array[i];
print(array,N);
}
void print(const int *p,int n)
{
int i;
//*p = 2;    p所指向的数组中的值为常量，所以不能更改！！！
cout<<"{"<<*p;
for(i = 1;i < N;i++)
cout<<","<<*(p+i);
cout<<"}"<<endl;
}
注意：*p = 2;    p所指向的数组中的值为常量，所以不能更改！！
****************************************************************************
    (2).常引用
常引用所引用的对象不能被更新；
   const  <类型说明符> & <引用名>
   则： v = 12.3错误


#include<iostream.h>
class K 
{
public:
K(int i) { k = i;}
int setk() const { return k; }  //常成员函数
private:
int k;
};
int add(const K & g1,const K & g2);//常引用做形参
void main()
{
K k1(8),k2(17);
int s = add(k1,k2);            //非常引用做实参
cout<<s<<endl;
}
int add(const K &g1,const K & g2)
{
int sum=g1.setk() + g2.setk();
return sum;
}
总结：a.常引用做形参
      b.非常引用做实参
*****************************    
常指针与常引用的作用
    使用常参数表明该函数不会更新某个参数所指向或所引用的对象，并
使该函数具有更大的适应性。
*****************************
*********************************************************************************** 
    (3)常成员函数
使用const关键字进行说明的成员函数：
   <类型说明符>  <函数名>  （<参数表>） const;
说明：
   const是函数类型的一个组成部分，在函数实现部分必须带有const关键字；
》》》只有常成员才能操作常对象；
成员函数与对象之间的操作关：
a.常成员函数可以操作【常对象】和【一般对象】。
b.一般成员函数只能操作【一般对象】。
注：上述中是对象。
#include<iostream.h>
class M
{
public:
M(int x,int y) { X =x;Y = y; }
void Move(int x,int y) { X = x;Y = y;}
void Print()  const { cout<<X<<","<<Y<<endl; }
private:
int X,Y;
};
void main()
{
const M m1(1,2);
//m1.Move(3,3);      //一般成员函数，不能操作常对象
m1.Print();
M m2(3,4);
m2.Move(3,3);
m2.Print();
}
*********************************************************************************************
   （4）常成员函数的重载
#include<iostream.h>
class R
{
public:
R(int r1,int r2) { R1 = r1;R2 = r2; }
void Print() { cout<<R1<<":"<<R2<<endl; }
void Print() const { cout<<R1<<";"<<R2<<endl; }
private:
int R1,R2;
};
void main()
{
R a(5,4);
a.Print();      //非常函数只能操作非常对象
const R b(3,8);
b.Print();      //常函数可以操作常或非常对象，默认选常对象。
}
总结：a.非常函数只能操作非常对象
      b.常函数可以操作常或非常对象，默认选常对象
***********************************************************************************************


    (5)常数据成员
const类型对象必须被初始化，并且不能被更新。
》常数据成员只能通过成员初始化列表的方法来进行初始化；
#include<iostream.h>
class A
{
public:
A(int i);
void Print();
private:
const int a;
static const int b;
const int & r;
const int c;
};
const int A::b=10;         //私有常静态数据
A::A(int i):a(i),r(a),c(5) //成员初始化列表，常成员(除静态成员外)在此初始化
{                          //常成员必须利用构造函数传递的数值进行赋值


}
void  A::Print()
{
cout<<a<<":"<<b<<":"<<r<<c<<endl;
}
void main()
{
A a1(100),a2(0);
a1.Print();
a2.Print();
}
总结：a.私有常静态数据必须在类体外进行赋值。
      b.常成员在成员初始化列表赋值，常成员(除静态成员外)在此初始化
      c.常成员必须利用构造函数传递的数值进行赋值


*****************************
类型适应
    一种类型的变量或对象能够用于另一种类型的变量或对象可以使用的
环境；
例如：非常对象使用在常对象中，就是类型适应，反之则不是；
*****************************
**********************************************************************************************