1.size_type && value_type
---------------------------------------------------------------------------------------------------------------------------------------------------
由string类类型和vector类类型定义的类型，用以保存任意string对象或vector对象的长度，标准库类型将size_type定义为unsigned类型 string抽象意义是字符串， size（）的抽象意义是字符串的尺寸， string::size_type抽象意义是尺寸单位类型 string::size_type它在不同的机器上，长度是可以不同的，并非固定的长度。但只要你使用了这个类型，就使得你的程序适合这个机器。与实际机器匹配。 eg string::size_type从本质上来说，是一个整型数。关键是由于机器的环境，它的长度有可能不同。 例如：我们在使用 string::find的函数的时候，它返回的类型就是 string::size_type类型。而当find找不到所要找的字符的时候，它返回的是 npos的值，这个值是与size_type相关的。假如，你是用 string s; int rc = s.find(.....); 然后判断，if ( rc == string::npos ) 这样在不同的机器平台上表现就不一样了。如果，你的平台的string::size_type的长度正好和int相匹配，那么这个判断会侥幸正确。但换成另外的平台，有可能 string::size_type的类型是64位长度的，那么判断就完全不正确了。 所以，正确的应该是： string::size_type rc = s.find(.....); 这个时候使用 if ( rc == string::npos )就回正确了。 st.size()表示st中的字符数量，字符数量的统计是由 1 开始累计计算的，所以字符数量正好比字符串的下标索引数（由 0 开始累计计算）大 1 ，这里的index != st.size();的效果等同于index < st.size();
当你使用容器的索引时（如果有的话），就用size_type，这是最可靠，最具备移植性的类型。
当你要创建与容器元素同样类型的对象时，就用value_type，代码将更灵活，更gener
一.C语言中的const
const是C语言中保留的一个关键字，它用来限定一个变量是只读的，即不可变的。程序中使用const可以在一定程度上提高程序的健壮性，但是程序中使用过多的const，可能在对代码的阅读时增加一定的难度。
(1)用const修饰一般变量
注意在C语言中，用const修饰的变量必须在声明时进行初始化(用来修饰函数的形参除外);
如:
const int n; 这种声明方式是错误的
const int n=5; 正确
void fun(const int n); 正确
const char a; 错误
char * const p; 错误
const char *p;正确(注意这种为什么是正确的),因为这里const是修饰p指向的变量,而不是指针变量p本身
一旦一个变量被const修饰后，在程序中除初始化外对这个变量进行的赋值都是错误的。
如:
const int n=5;
n=3; 错误
(2)const与指针搭配使用
首先必须弄清楚两个基础概念:指针常量和常量指针
指针常量:即指针本身的值是不可改变的，而指针指向的变量的值是可以改变的;
常量指针:即指针指向的变量的值是不可改变的，而指针本身的值是可以改变的;
可以这样去理解:因为指针本身也是一个变量，只不过指针存放的是地址而已，而一旦指针变成了常量，即指针本身的值是不可变的，此时指针只能指向固定的存储单元;指针一般会指向一个变量，如果该变量成为一个常量，那么该变量的值就不能被修改，即常量指针，指针指向的是一个不可变的变量。
如:
1 int a=3; 2 const int *p=&a; 3 int const *p1=&a; 4 *p=4; 5 a=4;
第2行和第3行是等价的;
第四行是错误的，因为用const限定p指向的变量的值是不可修改的，即不可通过指针p去修改变量a的值;
第五行是正确的，因为a本身没用const进行修饰，即a本身的值是可以修改的.
1 int a=1; 2 int b=2; 3 const int *p; 4 int const *p1; 5 int * const p2; 6 int * const p3=&b 7 p=&a; 8 p1=&a; 9 p2=&b; 10 p3=&a;
第3、4、7、8行是正确的;
第5行是错误的，第6行是正确的，第10行是错误的，因为const在'*'后面，表示是来修饰指针变量本身，因此在声明时必须进行初始化，并且在后面不能再指向其它的变量.
#include<stdio.h> int main(void) { const int a=3; int *pa=&a; *pa=4; printf("%d\n",*pa); printf("%d\n",a); return 0; } 编译结果: e:\c++\test\test.c(6) : warning C4090: 'initializing' : different 'const' qualifiers
输出结果是: 4
4
从这里可以看出a的值被修改了,在C语言中用const去修饰整形变量a，即a的值是不可变的，不能显式地通过赋值语句去改变a的值，
但是不代表在程序中不能通过其它方法来修改这个值。
总结:(1)在C语言中用const去修饰一个变量，表示这个变量是只读的，不可通过显式的调用a去修改a的值，并且此时a仍然是一个变 量，不能等同于常量;
(2)要注意const在声明变量时所处的位置，位置不同，在意义上可能会有很大的不同。
如果const在'*'左边，则表示指针指向的变量的值不可变;
如果const在'*'右边，则表示指针的值是不可变的;
二.C++中的const
C语言和C++中的const有很大区别。在C语言中用const修饰的变量仍然是一个变量;而在C++中用const修饰过后，就变成常量了。
如:
const int n=5; int a[n];
这种方式在C语言中会报错，原因在于声明数组时数组的长度必须为一个constant，即常量，虽然n用const限定了，但n终究是一个变量，因此会报错;
但是在C++中不会报错，因为在C++中用const修饰过后，n就已经等同于一个常量了，因此可以通过。
又如:
#include<iostream>using namespace std; int main(void) { const int a=3; int *pa=&a; *pa=4; printf("%d\n",*pa); printf("%d\n",a); return 0; } 编译结果:e:\c++\acm\lianxi.cpp(7) : error C2440: 'initializing' : cannot convert from 'const int *' to 'int *'
==========================================================================
const类型定义：指明变量或对象的值是不能被更新,引入目的是为了取代预编译指令
**************常量必须被初始化*************************
cons的作用
（1）可以定义const常量 例如：
const int Max=100;
int Array[Max];
（2）便于进行类型检查 例如：
void f(const int i) { .........}
编译器就会知道i是一个常量，不允许修改；
（3）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。
还是上面的例子，如果在函数体内修改了i，编译器就会报错；
例如：
void f(const int i) { i=10;//error! }
(5) 为函数重载提供了一个参考。
class A
{
......
void f(int i) {......} file://一个函数
void f(int i) const {......} file://上一个函数的重载
......
};
(6) 可以节省空间，避免不必要的内存分配。
例如：
#define PI 3.14159 file://常量宏
const doulbe Pi=3.14159; file://此时并未将Pi放入ROM中
......
double i=Pi; file://此时为Pi分配内存，以后不再分配！
double I=PI; file://编译期间进行宏替换，分配内存
double j=Pi; file://没有内存分配
double J=PI; file://再进行宏替换，又一次分配内存！
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
（7） 提高了效率。
编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。
使用const
（1）修饰一般常量,常数组，常对象
修饰符const可以用在类型说明符前，也可以用在类型说明符后。 例如：
int const x=2; 或 const int x=2;
int const a[5]={1, 2, 3, 4, 5}; 或 const int a[5]={1, 2, 3, 4, 5};
class A; const A a; 或 A const a;
（2）修饰指针
const int *A; 或 int const *A; //const修饰指向的对象，A可变，A指向的对象不可变
int *const A; //const修饰指针A， A不可变，A指向的对象可变
const int *const A; //指针A和A指向的对象都不可变
（3）修饰引用
const double & v; 该引用所引用的对象不能被更新
（4）修饰函数的返回值：
const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下：
const int Fun1();
const MyClass Fun2();
（5）修饰类的成员函数：
const修饰符也可以修饰类的成员函数，格式如下：
class ClassName
{
public:
int Fun() const;
.....
}；
这样，在调用函数Fun时就不能修改类里面的数据
（6）在另一连接文件中引用const常量
extern const int i; //正确的引用
extern const int j=10; //错误！常量不可以被再次赋值
*******************放在类内部的常量有什么限制？
class A
{
private:
const int c3 = 7; // err
static int c4 = 7; // err
static const float c5 = 7; // err
......
};
初始化类内部的常量
1 初始化列表：
class A
{
public:
A(int i=0):test(i) {}
private:
const int i;
}；
2 外部初始化，例如：
class A
{
public:
A() {}
private:
static const int i;
}；
const int A::i=3;
3.explict 关键字分析
C++提供了关键字explicit，可以阻止不应该允许的经过转换构造函数进行的隐式转换的发生。声明为explicit的构造函数不能在隐式转换中使用。
C++中， 一个参数的构造函数， 承担了两个角色。 1 是个构造器 2 是个默认且隐含的类型转换操作符。
所以， 有时候在我们写下如 AAA = XXX， 这样的代码， 且恰好XXX的类型正好是AAA单参数构造器的参数类型， 这时候编译器就自动调用这个构造器， 创建一个AAA的对象。
这样看起来好象很酷， 很方便。 但在某些情况下（见下面权威的例子）， 却违背了我们（程序员）的本意。 真是成也萧何， 败也萧何。 这时候就要在这个构造器前面加上explicit修饰， 指定这个构造器只能被明确的调用，使用， 不能作为类型转换操作符被隐含的使用。 呵呵， 看来还是光明正大些比较好。
关于这一点，《more effective c++》上也给出了详细的解释：
例如比较Array<int>对象，部分代码如下：
bool operator==( const Array<int>& lhs,
const Array<int>& rhs);
Array<int> a(10);
Array<int> b(10);
...
for (int i = 0; i < 10; ++i)
if (a == b[i]) { // 哎呦! "a" 应该是 "a[i]"
do something for when a[i] and b[i] are equal;}
else {
do something for when they're not;
}
我们想用a的每个元素与b的每个元素相比较，但是当录入a时，我们偶然忘记了数组下标。当然我们希望编译器能报出各种各样的警告信息，但是它根本没有。因为它把这个调用看成用Array<int>参数(对于a)和int(对于b[i])参数调用operator==函数，然而没有operator==函数是这样的参数类型，我们的编译器注意到它能通过调用Array<int>构造函数能转换int类型到Array<int>类型，这个构造函数只有一个int类型的参数。然后编译器如此去编译，生成的代码就象这样：
for (int i = 0; i < 10; ++i)
i f (a == static_cast< Array<int> >(b[i])) ....
容易的方法是利用一个最新编译器的特性，explicit关键字。为了解决隐式类型转换而特别引入的这个特性，它的使用方法很好理解。构造函数用explicit声明，如果这样做，编译器会拒绝为了隐式类型转换而调用构造函数。显式类型转换依然合法：
template<class T>
class Array {
public:
...
explicit Array(int size); // 注意使用"explicit"
...
};
Array<int> a(10); // 正确, explicit 构造函数, 在建立对象时能正常使用
Array<int> b(10); // 也正确
if (a == b[i]) ... // 错误! 没有办法 隐式转换int 到 Array<int>
由此看到explicit有些时候是非常有用的。
-------------------------------------------------------------------------
1908
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
