2.const修饰指针
W一U情况：const int *ptr=&a; ptr为指向常量的指针Q其所指的g可修改，但是其所指向的地址可以修改?/span>
W二U情况：int * const ptr=&aQ?/span>ptr为常量指针，其所指的地址不可被修改，但是其所指的值可以被修改?/span>
W三U情况：const int * const ptr=&aQ?/span>ptr为指向常量的帔R指针Q其所指向的地址不可修改Q其所指向的g不可修改?/span>
实例Q?br>
#include <iostream>2
using namespace std ;3
4
int main()5
{6
7
int a=1;8
int b=2;9
int c=3;10
int d=4;11
12
13
//W一U情?14
const int * ptr_one=&a;15
16
// *ptr_one=3; 错误ptr为指向常量的指针Q其所指的g能修?/span>17
18
ptr_one=&b;//正确Qptr所指向的地址可以修改19
20
21
//W二U情?22
int *const ptr_two=&c;23
24
//ptr_two=&d;//错误Qptr_two为常量指针，其所指的地址不可修改25
26
*ptr_two=4;//正确Qprt_two所指向的值可以修?br>2728
29
//W三U情况：30
const int * const ptr_three=&a;31
32
//*ptr_three=5; 错误Qptr_three为指向常量的帔R指针Q其所指向的g可修?br>3334
//ptr_three=&b; 错误Qptr_three所指向的地址不可修改35
36
37
}3.const 用于函数参数
直接看实例：
void fun_one(const int * r)2
{3
4
//*r=1;//错误Q不能在函数内改变r所指向的?/span>5
6
}7
8
void fun_two(int * const r)9
{10
11
//r=new int(1);//错误Q不能改变r所指向的地址12
13
}14
15
void fun_three(const int r)16
{17
18
//r=1;//错误Q不能改变r的?/span>19
20
}4.const 对于c?/span>
{1}对于const 修饰的类成员变量Q只能在构造函数的参数初始化表里对其进行初始化Q否则会引v~译错误?/span>
Q?/span>2Q对?/span>const 修饰的成员函?/span> Q如 int FunQ?/span>int aQ?/span>constQ这样声明之后Q何企囑֜函数内部修改成员变量的值或者调用非const成员函数都会引v~译错误?/span>
Q?/span>3Q对?/span>const声明的用戯定义cȝ对象Q如果调用这个类的非const成员函数Q将会引L译错误，~译器会保证?/span>const对象的生命期内不被改变?/span>
如果const对象一定要调用此函数的话，那就此函数声明?/span>const?br>实例Q?br>
#include <iostream>2
using namespace std ;3
4
class Test5
{6
public:7
8
Test():const_value(0)9
{10
value=0;11
}12
13
14
15
Test(int i,int m):const_value(m)16
{17
value=i;18
}19
20
void PrintValue() const21
{22
cout<<"\nValue的gؓQ?/span>"<<value;23
24
}25
26
private:27
int value;28
const int const_value;29
30
};31
32
33
int main()34
{35
36
Test a(5,5);37
a.PrintValue();38
39
const Test b(6,6);40
b.PrintValue();41
42
}]]>
#include <stdio.h>2
#include <iostream>3
4
using namespace std;5
6
7
8
9
class C 10
{11
public:12
int i;13
C(const C&) // an copy constructor14
{15
printf("\nin the copy constructor");16
}17
explicit C(int i ) // an explicit constructor18
{19
printf("\nin the constructor");20
}21
22
operator int()const //classs ->int23
{24
printf("\noperator int()");25
return i;26
}27
28
C()29
{30
i = 0;31
}32
};33
34
void test_fun1(C obj);35
void test_fun2(int i);36
void test_fun3(C c);37
38
39
int main()40
{41
C c, d;42
test_fun3(c); // c is copied43
44
//test_fun1(1);//错误Q因为构造函数声明了explicitQ所以禁止隐式{?/span>45
46
test_fun2(c); //call operator int()const47
test_fun1(c);48
cin.get();49
return 0;50
}51
52
void test_fun1(C obj)53
{54
}55
56
void test_fun2(int i)57
{58
}59
60
void test_fun3(C c)61
{62
}#include <string>2
#include <iostream>3
4
using namespace std;5
6
class Number {7
public:8
string type; 9
10
Number(): type("void") { }11
explicit Number(short) : type("short") { } 12
Number(int) : type("int") { }13
};14
void Show(const Number& n) { cout << n.type; }15
void f()16
{17
short s = 42;18
Show(s); 19
}20
int main()21
{22
f();23
cin.get();24
return 0;25
}26
]]>
/*******************************************************************************
* SGI*STL是STL之父Alexander Stepanov和STL巨匠Matt Austern{h的作? 是当?nbsp; *
* 最富盛名、最的STL实现版本Q全部源代码和说明文档可?a href="http://www.sgi.com/STL/?>www.sgi.com/STL/?/font> *
* ? 是我们学习STL的最佌? 但是众所周知, STL使用了大量复杂艰qC++Ҏ? *
* 加上STL本n的复杂和庞大, 使得阅读代码本n成Z仉常困隄工作. 以下?nbsp; *
* 字是我在学习STLq程中得到的一些经验和猜测, 希望能对大家有所帮助, 更希望能 *
* 得到大家的批评和指正, 以利于我们的共同提高. *
* myan *
*******************************************************************************/
在SGI*STL源代码里, typenameq个新的C++关键字得使用可以说是随处可见. 很多以前学习q?br>C++的h可能q不认识typename, 其实它的常规用法很简? 在声明模板函数或者模板类?
传统的写?
template <class T>
generic_function() {
//........
}
亦可以写?br>template <typename T>
------------
generic_func() {
//...............
}
引入q个关键字主要是Z避免class可能lh带来的?
本来typename的用法就是这么简? 但是STL源代码中q有typename的一U不常见的用? 如果
不了? 阅读源代码时׃遇到困难. 因ؓ目前我找不到有关q个问题的说? 所以自p验了
一? 得到一个猜? 现简介如? h识之士斧?
首先看一DSGI*STL源代? 摘自stl_iterator.h
1: template <class _Container, class _Iterator>
2: inline insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
3: {
4: typedef typename _Container::iterator __iter;
5: return insert_iterator<_Container>(__x, __iter(__i));
6: }
令h费解的部分在W四? 请大家在看我的解释之前先想一? 我不敢保证下面解释的正确性和
全面?
解释:
我认为typename的语义是: 通知~译? 在typename后面被声明的东西是一个类? 而不是别?br>什么东?
例子:2
// tpname.cpp3
#include <iostream>4
#include <typeinfo> // for typeid() operator5
6
using namespace std;7
8
template <typename TP>9
struct COne { // default member is public10
typedef TP one_value_type;11
};12
13
template <typename COne> // 用一个模板类作ؓ模板参数, q是很常见的14
struct CTwo {15
// h意以下两?br>16 // typedef COne::one_value_type two_value_type; // *117
typedef typename COne::one_value_type two_value_type; // *2 18
};19
20
// 以上两个模板cd是定义了两个内部的publiccd, 但请注意W二个类CTwo的two_value_typecd21
// 依赖COne的one_value_type, 而后者又取决于COne模板cd例化时传入的参数cd.22
23
int main()24
{25
typedef COne<int> OneInt_type;26
typedef CTwo< OneInt_type > TwoInt_type;27
TwoInt_type::two_value_type i;28
int j;29
if ( typeid(i) == typeid(j) ) // 如果i是int型变?/span>30
cout << "Right!" << endl; // 打印Right31
return;32
}33
// ~tpname.cpp34
以上例子在Linux下用G++ 2.91~译通过, l果打印"Right". 但是如果?1行的注释号去? 注释
*2? 则编译时报错, ~译器不知道COne::one_value_typeZ? 通常在模板类参数中的cd?br>实例化之后才会显露真w? 但这个CTwocd偏又要依赖一个已l存在的COne模板c? 希望能够预先
保证CTwo::two_value_type与COne::one_value属于同一cd, q是只好请typename出山, 告诉
~译? 后面的COne::one_value_type是一个已l存在于某处的类型的名字(type name), q样~译
器就可以利的工作了.
]]>
int readFile(CString& str, const CString& strPathName) { FILE* fp = fopen(strPathName, "r"); // 打开文g fseek(fp, 0, SEEK_END); int nLen = ftell(fp); // 获得文g长度 fseek(fp, 0, SEEK_SET); // 重置L?/span> char* psz = str.GetBuffer(nLen); fread(psz, sizeof(char), nLen, fp); //L件内?/span> str.ReleaseBuffer(); //千万不能~少 fclose(fp); }]]>
--------------指针----------------
int a=10;
int *p=&a;
-------------指针的指?----------
int b=20;
int *p=&b;
int **p2p=&p;
-------------单数l?----------------
int c[10];//整数数组Q含?0个整数元?br>也就是说每一个元素都是整?br>
--------------指针数组--------------------
int *p[10];//指针数组Q含?0个指针元?br>也就是说每一个元素都是指?br>
--------------数组指针--------------------
int (*p)[10];//数组指针Q这个指针能够用来指?br>含有10个元素的整数数组
------------函数指针---------------------
int (*p)( ); // 指向函数的指?..q里声明了一个指针pQ该指针指向q回值是整型Q即函数cd为整型）的函敎ͼ
----------------指针函数---------------------------
int *p(int a,float b); //q回gؓ指针的函?..该函数返回指向整型变量的指针Q?/font>
卌函数的类型ؓint *, p和上例不同，他是函数名！上例中是指针Q?/font>
===========================================================================
C/C 中函数指针的含义
作者：宁
函数存放在内存的代码区域内，他们同样有地址Q我们如何能获得函数的地址呢？
假如我们有一个int test(int a)的函敎ͼ那么Q他的地址是函数的名字，q一点如同数l相同，数组的名字就是数l的起始地址?
定义一个指向函数的指针用如下的形式Q以上面的test()ZQ?
int (*fp)(int a);//q里定义了一个指向函数的指针
函数指针不能l对不能指向不同cdQ或是带不同形参的函敎ͼ在定义函数指针的时候我们很Ҏ犯如下的错误?/font>
int *fp(int a);//q里是错误的Q因为按照结合性和优先U来看就是先?)l合Q然后变成了一个返回整形指针的函数了，而不是函数指针，q一点尤光要注意！
下面我们来看一个具体的例子Q?/font>
#include <iostream>
#include <string>
using namespace std;
int test(int a);
void main(int argc,char* argv[])
{
cout<<test<<endl;//昄函数地址
int (*fp)(int a);
fp=test;//函数test的地址赋给函数学指针fp
cout<<fp(5)<<"|"<<(*fp)(10)<<endl;
//上面的输出fp(5),q是标准c 的写?(*fp)(10)q是兼容c语言的标准写?两种同意,但注意区?避免写的E式产生UL性问?
cin.get();
}
int test(int a)
{
return a;
}
typedef定义能够化函数指针的定义Q在定义一个的时候感觉不出来Q但定义多了q道方便了Q上面的代码改写成如下的形式Q?/font>
#include <iostream>
#include <string>
using namespace std;
int test(int a);
void main(int argc,char* argv[])
{
cout<<test<<endl;
typedef int (*fp)(int a);//注意,q里不是生命函数指针,而是定义一个函数指针的cd,q个cd是自己定义的,cd名ؓfp
fp fpi;//q里利用自己定义的类型名fp定义了一个fpi的函数指?
fpi=test;
cout<<fpi(5)<<"|"<<(*fpi)(10)<<endl;
cin.get();
}
int test(int a)
{
return a;
}
函数指针同样是能够作为参C递给函数的，下面我们看个例子Q仔l阅L会发现他的用处Q稍加推理能够很方便我们q行一些复杂的~程工作?/font>
//-------------------该例以上一个例子作为基E加了修?----------------------------
#include <iostream>
#include <string>
using namespace std;
int test(int);
int test2(int (*ra)(int),int);
void main(int argc,char* argv[])
{
cout<<test<<endl;
typedef int (*fp)(int);
fp fpi;
fpi=test;//fpi赋予test 函数的内存地址
cout<<test2(fpi,1)<<endl;//q里调用test2函数的时?q里把fpi所存储的函数地址(test的函数地址)传递了ltest2的第一个Ş?
cin.get();
}
int test(int a)
{
return a-1;
}
int test2(int (*ra)(int),int b)//q里定义了一个名字ؓra的函数指?
{
int c=ra(10) b;//在调用之?ra已指向fpi所指向的函数地址即test函数
return c;
}
利用函数指针Q我们能够构成指针数l，更明点的说法是构成指向函数的指针数l，q么说可能就Ҏ理解的多了?/font>
#include <iostream>
#include <string>
using namespace std;
void t1(){cout<<"test1";}
void t2(){cout<<"test2";}
void t3(){cout<<"test3";}
void main(int argc,char* argv[])
{
void* a[]={t1,t2,t3};
cout<<"比较t1()的内存地址和数la[0]所存储的地址是否一?<<t1<<"|"<<a[0]<<endl;
cout<<a[0]();//错误!指针数组是不能利用数l下标操作调用函数的
typedef void (*fp)();//自定义一个函数指针类?
fp b[]={t1,t2,t3}; //利用自定义类型fp把b[]定义一个指向函数的指针数组
b[0]();//现在利用指向函数的指针数l进行下标操作就能够q行函数的间接调用了;
cin.get();
}
仔细看上面的例子可能不用我多说大家也会知道是怎么一会事情了,最后我们做一个重点小l?只要Cq一?对于理解利用函数指针构成数组q行函数间接调用很Ҏ?
void* a[]={t1,t2,t3};
cout<<"比较t1()的内存地址和数la[0]所存储的地址是否一?<<t1<<"|"<<a[0]<<endl;
cout<<a[0]();//错误!指针数组是不能利用数l下标操作调用函数的
上面的这一段中的错误行，Z么不能这么调用呢Q?
前一教E我们已说的很清楚了Q但是在q里我们q是复习一下概念，指针数组元素所保存的只是个内存地址Q既然只是个内存地址׃可能q行a[0]()q样地址带括L操作Q而函数指针不同他是个例外Q函数指针只所以这么叫他就是因Z是指向函数指向内存的代码区的指针Q他被系l授予允许和()括号操作的权利，q行间接的函数调用，既然函数指针允许q么操作Q那么被定义成函数指针的数组׃定是能够相同的操作的?/font>
]]>