久久午夜免费视频,国产精品久久久天天影视,欧美亚洲日本久久精品

C++关键字之const

Fri, 27 Jun 2008 14:16:00 GMT

1. const int r=100; //标准const变量声明加初始化�Q�因为默认内部连接所以必��被初始化，其作用域为此文�g�Q�编译器�l�过�c�d��查后直接�?/span>100在编译时替换

2.const修饰指针

�W�一�U�情况：const int *ptr=&a; ptr为指向常量的指针�Q�其所指的��g��可修改，但是其所指向的地址可以修改�?/span>

�W�二�U�情况：int * const ptr=&a�Q?/span>ptr为常量指针，其所指的地址不可被修改，但是其所指的值可以被修改�?/span>

�W�三�U�情况：const int * const ptr=&a�Q?/span>ptr为指向常量的帔R��指针�Q�其所指向的地址不可修改�Q�其所指向的��g��不可修改�?/span>

实例�Q?br>

1#include <iostream>
2using namespace std ;
3
4int 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;//正确�Q�ptr所指向的地址可以修改
19
20
21    //�W�二�U�情�?
22    int *const ptr_two=&c;
23
24    //ptr_two=&d;//错误�Q�ptr_two为常量指针，其所指的地址不可修改
25
26    *ptr_two=4;//正确�Q�prt_two所指向的值可以修�?br>27
28
29    //�W�三�U�情况：
30    const int * const ptr_three=&a;
31
32    //*ptr_three=5; 错误�Q�ptr_three为指向常量的帔R��指针�Q�其所指向的��g��可修�?br>33
34    //ptr_three=&b;  错误�Q�ptr_three所指向的地址不可修改
35
36
37}

3.const 用于函数参数
直接看实例：

1void fun_one(const int * r)
2{
3
4//*r=1;//错误�Q�不能在函数内改变r所指向的�?/span>
5
6}
7
8void fun_two(int * const r)
9{
10
11//r=new int(1);//错误�Q�不能改变r所指向的地址
12
13}
14
15void 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>2�Q�对�?/span>const 修饰的成员函�?/span> �Q�如 int Fun�Q?/span>int a�Q?/span>const�Q�这样声明之后�Q何企囑֜�函数内部修改成员变量的值或者调用非const成员函数都会引�v�~�译错误�?/span>

�Q?/span>3�Q�对�?/span>const声明的用戯��定义�cȝ��对象�Q�如果调用这个类的非const成员函数�Q�将会引��L��译错误，�~�译器会保证�?/span>const对象的生命期内不被改变�?/span>

如果const对象一定要调用此函数的话，那就��此函数声明�?/span>const�?br>实例�Q?br>

1#include <iostream>
2using namespace std ;
3
4class Test
5{
6public:
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
20void    PrintValue() const
21    {
22    cout<<"\nValue的��gؓ�Q?/span>"<<value;
23
24    }
25
26private:
27    int value;
28    const int const_value;
29
30};
31
32
33int main()
34{
35
36Test a(5,5);
37a.PrintValue();
38
39const Test b(6,6);
40b.PrintValue();
41
42}

杨�{�?/a> 2008-06-27 22:16 发表评论

C++关键字之explicit

Wed, 25 Jun 2008 13:36:00 GMT

一个explicit关键字声明的构造函数禁止编译器�q�行隐式�c�d��转换 .�Q?font face=Arial>��止单参数构造函�?被用于自动型别�{�?/font>�Q?br>参考如下代码：

1#include <stdio.h>
2#include <iostream>
3
4using namespace std;
5
6
7
8
9class C
10{
11public:
12    int i;
13    C(const C&)   // an  copy constructor
14    {
15        printf("\nin the copy constructor");
16    }
17    explicit C(int i )   // an explicit constructor
18    {
19        printf("\nin the constructor");
20    }
21
22    operator int()const //classs ->int
23    {
24        printf("\noperator int()");
25        return i;
26    }
27
28    C()
29    {
30        i = 0;
31    }
32};
33
34void test_fun1(C obj);
35void test_fun2(int i);
36void test_fun3(C c);
37
38
39int main()
40{
41    C c, d;
42    test_fun3(c);   // c is copied
43
44    //test_fun1(1);//错误�Q�因为构造函数声明了explicit�Q�所以禁止隐式�{�?/span>
45
46    test_fun2(c); //call operator int()const
47    test_fun1(c);
48    cin.get();
49    return 0;
50}
51
52void test_fun1(C obj)
53{
54}
55
56void test_fun2(int i)
57{
58}
59
60void test_fun3(C c)
61{
62}

从网上看到这�D�代码：

1#include <string>
2#include <iostream>
3
4using namespace std;
5
6class 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    }
20int main()
21{
22f();
23cin.get();
24return 0;
25}
26

�q�段代码的返回��gؓ�Q�int�Q�这里面起关键作用的��是那个explicit

杨�{�?/a> 2008-06-25 21:36 发表评论

C++关键字typename(转蝲)

Tue, 24 Jun 2008 13:56:00 GMT

转蝲自：http://dev.csdn.net/article/3/3354.shtm

/*******************************************************************************
* 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使用了大量复杂艰��q��C++�Ҏ(gu��)�? *
* 加上STL本��n的复杂和庞大, 使得阅读代码本��n��成��Z��仉��常困隄��工作. 以下�?nbsp; *
* 字是我在学习STL�q�程中得到的一些经验和猜测, 希望能对大家有所帮助, 更希望能 *
* 得到大家的批评和指正, 以利于我们的共同提高. *
* myan *
*******************************************************************************/

在SGI*STL源代码里, typename�q�个新的C++关键字得使用可以说是随处可见. 很多以前学习�q?br>C++的�h可能�q�不认识typename, 其实它的常规用法很简�? 在声明模板函数或者模板类�?
传统的写�?
template
generic_function() {
//........
}

亦可以写�?br>template
------------
generic_func() {
//...............
}
引入�q�个关键字主要是��Z��避免class可能�l��h带来的�؜�?
本来typename的用法就是这么简�? 但是STL源代码中�q�有typename的一�U�不常见的用�? 如果
不了�? 阅读源代码时��׃��遇到困难. 因�ؓ目前我找不到有关�q�个问题的说�? 所以自��p��验了
一�? 得到一个猜��? 现简介如�? ��h��识之士斧�?

首先看一�D�SGI*STL源代�? 摘自stl_iterator.h

1: template
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>什么东�?

1例子:
2// tpname.cpp
3#include <iostream>
4#include <typeinfo>  // for typeid() operator
5
6using namespace std;
7
8template <typename TP>
9struct COne {   // default member is public
10    typedef TP one_value_type;
11};
12
13template <typename COne>   // 用一个模板类作�ؓ模板参数, �q�是很常见的
14struct CTwo {
15    // ��h��意以下两�?br>16    // typedef COne::one_value_type  two_value_type;   // *1
17    typedef typename COne::one_value_type  two_value_type;      // *2
18};
19
20// 以上两个模板�c�d��是定义了两个内部的public�c�d��, 但请注意�W�二个类CTwo的two_value_type�c�d��
21// 依赖COne的one_value_type, 而后者又取决于COne模板�c�d��例化时传入的参数�c�d��.
22
23int 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;   // 打印Right
31    return;
32}
33//  ~tpname.cpp
34

以上例子在Linux下用G++ 2.91�~�译通过, �l�果打印"Right". 但是如果�?1行的注释号去�? 注释
*2�? 则编译时报错, �~�译器不知道COne::one_value_type��Z��? 通常在模板类参数中的�c�d��?br>实例化之后才会显露真�w? 但这个CTwo�c�d��偏又要依赖一个已�l�存在的COne模板�c? 希望能够预先
保证CTwo::two_value_type与COne::one_value属于同一�c�d��, �q�是��只好请typename出山, 告诉
�~�译�? 后面的COne::one_value_type是一个已�l�存在于某处的类型的名字(type name), �q�样�~�译
器就可以��利的工作了.

杨�{�?/a> 2008-06-24 21:56 发表评论

GetBuffer与ReleaseBuffer的用法，CString剖析---转蝲

Mon, 23 Jun 2008 01:56:00 GMT

转蝲�?http://hi.baidu.com/idealsoft/blog/item/02d74322339097f6d6cae24e.html
�q�是一个非常容易被用错的函敎ͼ�主要可能是由于大家对它的功能不太了解。其实点破的话，也不是那么深奥�?br> GetBuffer(int size)是用来返回一个你所指定大小可写内存的成员方法。它和被重蝲的操作符LPCTSTR�q�是有点本质区别的，LPCTSTR是直接返回一个只��d��存的指针�Q�而GetBuffer则是�q�回一个可以供调用者写入的内存�Q��ƈ且，你可以给定大��。下面是个简单的�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);
    }

上面的函数是GetBuffer函数最典型的用法了�Q�其实它?y��u)��q��当于甌��一块nLen大小的内存，只不�q�，�q�块内存是被引用在CString对象的内部而已�Q�这是非常有效的一�U�用法，如果不直接用GetBuffer函数来申��L��话，那么你必��ȝ��new操作�W�（或者malloc()函数�Q�在CString的外部申��P��然后再将甌��的内存拷贝到CString对象中，昄��q�是一个非常冗余的操作�Q�会使你函数的效率大大下降�?br> ReleaseBuffer函数是用来告诉CString对象�Q�你的GetBuffer所引用的内存已�l��用完毕，现在必须对它�q�行��口�Q�否则CString��不会知道它现在所包含的字�W�串的长度，所以在使用完GetBuffer之后�Q�必��ȝ��卌��用ReleaseBuffer函数重置CString的内部属性，其实也就是头部信息�?br>

杨�{�?/a> 2008-06-23 09:56 发表评论

Sun, 22 Jun 2008 12:45:00 GMT

C++ 枚�D�c�d��的思�?转蝲)

原文�|�址: http://blog.csdn.net/classfactory/archive/2004/08/29/87749.aspx

C++ 中的枚�D�c�d��l�承�?C 语言。就像其他从 C 语言�l�承�q�来的很多特性一��P��C++ 枚�D也有�~�点�Q�这其中最显著的莫�q�于作用域问题——在枚�D�c�d��中定义的帔R��Q�属于定义枚丄��作用域，而不属于�q�个枚�D�c�d��。例如下面的�C�Z��Q?/p>

enum FileAccess {
Read = 0x1,
Write = 0x2,
};

FileAccess access = ::Read; // 正确
FileAccess access = FileAccess::Read; // 错误

C++枚�D的这个特点对于习惯面向对象和作用域概�늚�人来说是不可接受的。首先，FileAccess::Read 昄��更加�W�合�E�序员的直觉�Q�因��Z��面的枚�D定义理应�{��h(hu��n)于如下的定义�Q�实际上�Q?NET 中的枚�D�c�d��便是如此实现的）�Q?/p>

class FileAccess {
static const int Read = 0x1;
static const int Write = 0x2;
};

其次�Q�这��D��我们无法在同一个作用域中定义两个同样名�U�的枚�D倹{��也��是��_��以下的代码是�~�译错误�Q?/p>

enum FileAccess {
Read = 0x1,
Write = 0x2,
};

enum FileShare {
Read = 0x1, // 重定�?br> Write = 0x2, // 重定�?br>};

如果�q�一�Ҏ(gu��)��有让你恼怒过的话�Q�你可能�q�没写过多少 C++ 代码 :-)。实际上�Q�在最新的 C++0x 标准草案中有关于枚�D作用域问题的提案�Q�但最�l�的解决�Ҏ(gu��)��会是怎样的就无法未卜先知了，毕竟对于�?C++ �q�样使用�q�泛的语�a�来说�Q��Q何特性的增删和修攚w��必须十分��心谨慎�?/p>

当然�Q�我们可以��用一些迂回的�Ҏ(gu��)��来解册��个问题（C++ ��L��能给我们很多惊喜和意外）。例如，我们可以把枚丑ր�放在一个结构里�Q��ƈ使用�q�算�W�重载来��D��枚�D的特性：

struct FileAccess {
    enum __Enum {
        Read = 0x1,
        Write = 0x2
    };
    __Enum _value; // 枚�D�?/p>

    FileAccess(int value = 0) : _value((__Enum)value) {}
    FileAccess& operator=(int value) {
        this->_value = (__Enum)value;
        return *this;
    }
    operator int() const {
        return this->_value;
    }
};

我们现在可以按照希望的方式��用这个枚丄��型：

FileAccess access = FileAccess::Read;

�q�且�Q�因为我们提供了�?int �c�d��的�{换运��符�Q�因此在需�?int 的地斚w��可以使用它，例如 switch 语句�Q?/p>

switch (access) {
    case FileAccess::Read:
        break;
    case FileAccess::Write:
        break;
}

当然我们不愿意每�ơ都手工�~�写�q�样的结构。通过使用宏，我们可以很容易做到这一点：

#define DECLARE_ENUM(E) \
struct E \
{ \
public: \
    E(int value = 0) : _value((__Enum)value) { \
    } \
    E& operator=(int value) { \
        this->_value = (__Enum)value; \
        return *this; \
    } \
    operator int() const { \
        return this->_value; \
    } \
\
    enum __Enum {

#define END_ENUM() \
}; \
\
private: \
__Enum _value; \
};

我们现在可以按如下的方式定义前面的枚举，�q�且不比直接�?enum 复杂多少�?/p>

DECLARE_ENUM(FileAccess)
Read = 0x1,
Write = 0x2,
END_ENUM()

DECLARE_ENUM(FileShare)
Read = 0x1,
Write = 0x2,
END_ENUM()

杨�{�?/a> 2008-06-22 20:45 发表评论

指针, 指针的指�? 数组, 指针数组, 数组指针, 指针函数, 函数指针

Wed, 11 Jun 2008 09:00:00 GMT

指针, 指针的指�? 数组, 指针数组, 数组指针, 指针函数, 函数指针-----转蝲

--------------指针----------------
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�里声明了一个指针p�Q�该指针指向�q�回值是整型�Q�即函数�c�d��为整型）的函敎ͼ�

----------------指针函数---------------------------

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()��Z��Q?

int (*fp)(int a);//�q�里��定义了一个指向函数的指针

　　函数指针不能�l�对不能指向不同�c�d��Q�或是带不同形参的函敎ͼ�在定义函数指针的时候我们很�Ҏ(gu��)��犯如下的错误�?/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<//昄��函数地址
int (*fp)(int a);
fp=test;//��函数test的地址赋给函数学指针fp
cout<//上面的输出fp(5),�q�是标准c 的写�?(*fp)(10)�q�是兼容c语言的标准写�?两种同意,但注意区�?避免写的�E�式产生�U�L��性问�?
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<typedef int (*fp)(int a);//注意,�q�里不是生命函数指针,而是定义一个函数指针的�c�d��,�q�个�c�d��是自己定义的,�c�d��名�ؓfp
fp fpi;//�q�里利用自己定义的类型名fp定义了一个fpi的函数指�?
fpi=test;
cout<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<typedef int (*fp)(int);
fp fpi;
fpi=test;//fpi赋予test 函数的内存地址

cout<//�q�里调用test2函数的时�?�q�里把fpi所存储的函数地址(test的函数地址)传递了�l�test2的第一个�Ş�?
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�么说可能就�Ҏ(gu��)��理解的多了�?/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()的内存地址和数�l�a[0]所存储的地址是否一�?<
cout<//错误!指针数组是不能利用数�l�下标操作调用函数的

typedef void (*fp)();//自定义一个函数指针类�?
fp b[]={t1,t2,t3}; //利用自定义类型fp把b[]定义��一个指向函数的指针数组
b[0]();//现在利用指向函数的指针数�l�进行下标操作就能够�q�行函数的间接调用了;
cin.get();
}

　　仔细看上面的例子可能不用我多说大家也会知道是怎么一会事情了,最后我们做一个重点小�l?只要��C��q�一�?对于理解利用函数指针构成数组�q�行函数间接调用��很�Ҏ(gu��)��?

void* a[]={t1,t2,t3};
cout<<"比较t1()的内存地址和数�l�a[0]所存储的地址是否一�?<
cout<

　　上面的这一��段中的错误行，��Z��么不能这么调用呢�Q?

　　前一��教�E�我们已说的很清楚了�Q�但是在�q�里我们�q�是复习一下概念，指针数组元素所保存的只是个内存地址�Q�既然只是个内存地址��׃��可能�q�行a[0]()�q�样地址带括��L��操作�Q�而函数指针不同他是个例外�Q�函数指针只所以这么叫他就是因��Z��是指向函数指向内存的代码区的指针�Q�他被系�l�授予允许和()括号操作的权利，�q�行间接的函数调用，既然函数指针允许�q�么操作�Q�那么被定义成函数指针的数组��׃��定是能够相同的操作的�?/font>

原文地址 http://www.netinter.cn/info/html/chengxusheji/C-C--/20080224/11853.html

杨�{�?/a> 2008-06-11 17:00 发表评论