const用法主要是防止定义的对象再次被修改,定义对象变量时要初始化变量
下面我就介绍一下几种常见的用法
Const修饰变量必须初始化，修饰指针可以不初始化
如：int a1=1; const int *a; int *const a=&a1;
1.用于定义常量变量,这样这个变量在后面就不可以再被修改
const int Val = 10;
//Val = 20; //错误,不可被修改
2. 保护传参时参数不被修改,如果使用引用传递参数或按地址传递参数给一个函数,在这个函数里这个参数的值若被修改,
则函数外部传进来的变量的值也发生改变,若想保护传进来的变量不被修改,可以使用const保护
void fun1(const int &val)
{
//val = 10; //出错
}
void fun2(int &val)
{
val = 10; //没有出错
}
void main()
{
int a = 2;
int b = 2;
fun1(a); //因为出错,这个函数结束时a的值还是2
fun2(b);//因为没有出错,函数结束时b的值为10
}
如果只想把值传给函数,而且这个不能被修改,则可以使用const保护变量,有人会问为什么不按值传递,按值传递还需要把这个值复制一遍,
而引用不需要,使用引用是为了提高效率//如果按值传递的话,没必要加const,那样根本没意义
3. 节约内存空间,
#define PI 3.14 //使用#define宏
const double Pi = 3.14 //使用const,这时候Pi并没有放入内存中
double a = Pi; //这时候才为Pi分配内存,不过后面再有这样的定义也不会再分配内存
double b = PI; //编译时分配内存
double c = Pi; //不会再分配内存,
double d = PI; //编译时再分配内存
const定义的变量,系统只为它分配一次内存,而使用#define定义的常量宏,能分配好多次,这样const就很节约空间
4.类中使用const修饰函数防止修改非static类成员变量
class
{
public:
void fun() const //加const修饰
{
a = 10; //出错,不可修改非static变量
b = 10; //对,可以修改
}
private:
int a ;
static int b;
}
5.修饰指针const int *A; 或 int const *A; //const修饰指向的对象，A可变，A指向的对象不可变
int *const A; //const修饰指针A， A不可变，A指向的对象可变
const int *const A; //指针A和A指向的对象都不可变
6.修饰函数返回值,防止返回值被改变
const int fun();
接收返回值的变量也必须加const
const int a = fun(); //接收的变量也要是const的,int a = fun()是错误的
7.修饰类的成员变量(类是c++中的)
使用const修饰的变量必须初始化,在类中又不能在定义时初始化, 如;
class
{
private:
int a = 10;
const int b = 10;
static const int c = 10;
//这样初始化都是错的,
}
初始化const int类型(没有static),在类的构造函数上初始化
Class Test
{
Public:
Test():b(23) //构造函数上初始化b的值为23
{
}
private:
const int b ;
}
初始化staticconst int这个类型的(带有static的),在类的外面初始化
class Test
{
private:
static const int c;
}
const int Test::c=10; //类的外部初始化c为10
8.const定义的对象变量只能作用于这个程序该C/C++文件,不能被该程序的其他C/C++文件调用,
如file1.cpp中 const int val;
在file2.cpp中, extern intval; //错误,无法调用,
要想const定义的对象变量能被其他文件调用,定义时必须使用extern修饰为
extern const int val;
非const变量默认为extern,要是const能被其他文件访问必须显示指定为extern
const用法小结
前两天看代码的时候，发现很奇怪的const用法，于是在网上搜了一下，原来有这么多用法，不敢独享，拿上来和与我一样菜的小生们学习～
1. const常量，如const int max = 100;
优点：const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误（边际效应）
2. const 修饰类的数据成员。如：
class A
{
const int size;
…
}
const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const 数据成员的值是什么。如
class A
{
const int size = 100; //错误
int array[size]; //错误，未知的size
}
const数据成员的初始化只能在类的构造函数的初始化表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现。如
class A
{…
enum {size1=100, size2 = 200 };
int array1[size1];
int array2[size2];
}
枚举常量不会占用对象的存储空间，他们在编译时被全部求值。但是枚举常量的隐含数据类型是整数，其最大值有限，且不能表示浮点数。
3. const修饰指针的情况，见下式：
int b = 500;
const int* a = & [1]
int const *a = & [2]
int* const a = & [3]
const int* const a = & [4]
如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。不知道，也没关系，我们可以参考《Effective c++》Item21上的做法，如果const 位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。
4. const的初始化
先看一下const变量初始化的情况
1) 非指针const常量初始化的情况：A b;
const A a = b;
2) 指针const常量初始化的情况：
A* d = new A();
const A* c = d;
或者：const A* c = new A();
3）引用const常量初始化的情况：
A f;
const A& e = f; // 这样作e只能访问声明为const的函数，而不能访问一
般的成员函数；
[思考1]：以下的这种赋值方法正确吗？
const A* c=new A();
A* e = c;
[思考2]：以下的这种赋值方法正确吗？
A* const c = new A();
A* b = c;
5. 另外const 的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法：A& operator=(const A& a); void fun0(const A* a );
void fun1( ) const; // fun1( ) 为类成员函数
const A fun2( );
1）修饰参数的const，如 void fun0(const A* a ); void fun1(const A& a);
调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const 所修饰的部分进行常量化，如形参为const A* a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。
[注意]：参数const通常用于参数为指针或引用的情况，且只能修饰输入参数;若输入参数采用“值传递”方式，由于函数将自动产生临时变量用于复制该参数，该参数本就不需要保护，所以不用const修饰。
[总结]对于非内部数据类型的输入参数，因该将“值传递”的方式改为“const 引用传递”，目的是为了提高效率。例如，将void Func(A a)改为void Func(const A &a)
对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x)不应该改为void Func(const int &x)
2）修饰返回值的const，如const A fun2( ); const A* fun3( );
这样声明了返回值后，const按照"修饰原则"进行修饰，起到相应的保护作用。const Rational operator*(const Rational& lhs, const Rational& rhs) {
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
返回值用const修饰可以防止允许这样的操作发生:Rational a,b;
Radional c;
(a*b) = c;
一般用const修饰返回值为对象本身（非引用和指针）的情况多用于二目操作符重载函数并产生新对象的时候。
[总结]
1. 一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例），则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const
成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。
2. 如果给采用“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。如：
const char * GetString(void);
如下语句将出现编译错误：
char *str=GetString();
正确的用法是：
const char *str=GetString();
3. 函数返回值采用“引用传递”的场合不多，这种方式一般只出现在类的赙值函数中，目的是为了实现链式表达。如：
class A
{…
A &operate = (const A &other); //负值函数
}
A a,b,c; //a,b,c为A的对象
…
a=b=c; //正常
(a=b)=c; //不正常，但是合法
若负值函数的返回值加const修饰，那么该返回值的内容不允许修改，上例中a=b=c依然正确。(a=b)=c就不正确了。
[思考3]：这样定义赋值操作符重载函数可以吗？
const A& operator=(const A& a);
6. 类成员函数中const的使用
一般放在函数体后，形如：void fun() const;
任何不会修改数据成员的函数都因该声明为const类型。如果在编写const成员
函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将报错，这大大提高了程序的健壮性。如：
class Stack
{
public:
void Push(int elem);
int Pop(void);
int GetCount(void) const; //const 成员函数
private:
int m_num;
int m_data[100];
};
int Stack::GetCount(void) const
{
++m_num; //编译错误，企图修改数据成员m_num
Pop(); //编译错误，企图调用非const函数
Return m_num;
}
7. 使用const的一些建议
1 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
2 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
3 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
4 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
5 不要轻易的将函数的返回值类型定为const;
6除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;
[思考题答案]
1 这种方法不正确，因为声明指针的目的是为了对其指向的内容进行改变，而声明的指针e指向的是一个常量，所以不正确；
2 这种方法正确，因为声明指针所指向的内容可变；
3 这种做法不正确；
在const A::operator=(const A& a)中，参数列表中的const的用法正确，而当这样连续赋值的时侯，问题就出现了：
A a,b,c:
(a=b)=c;
因为a.operator=(b)的返回值是对a的const引用，不能再将c赋值给const 常量。
const修饰指针和引用的用法
const修饰指针和引用的用法,对于初学C++的人直是讳莫如深,不知所云.
一旦你了解了其用法,一切便不值一哂了.下面我为读者一一释疑:
大致说来其可分为三种情况: const修饰指针,const修饰引用,const修饰指针的引用.
1.const修饰指针
const修饰指针又可分为三种情况:
a.const修饰指针本身
b.const修饰指针所指的变量(或对象)
c.const修饰指针本身和指针所指的变量(或对象)
(1).const修饰指针本身
这种情形下,指针本身为常量,不可改变,任何修改指针本身的行为都是非法的.例如:
const int a = 1;
const int b = 2;
int i = 3;
int j = 4;
int* const pi = &i; //ok, pi的类型为int* const , &i的类型为int* const
int* const pi = &a; //error, pi的类型为int* const, &a的类型为const int* const
pi = &j; //error, 指针是常量,不可变
*pi = a; //ok, *pi并没有限定是常量 ,可变
由此看出，pi是常量，常量在初始化和赋值时，类型必须严格一致。也就是
const修饰指针本身时，=号两边的变量类型必须严格一致，否则不能匹配。
(2).const修饰指针指向的变量(或对象)
此种情形下,通过间接引用指针不可改变变量的值,假设指针为p,则*p 不可变,下面以例子说明:
const int *pi = &a;
//or int const *pi = &a;
//两者毫无二致,不过BS喜欢前者,这也没什么技术上的优劣之分,
//也就是说const int与int const以互换.建议大家熟
//悉这两种形式,为简洁便,以后统统用前者.
//ok, const并不修饰指针本身,pi对赋值类型
//没要求 ,但pi是int*型指针，所以所赋的必须是个地址值。
const int *pi = &i; //ok ,pi可赋值常量的地址,又可赋变量的地址 const int *pi1 = &a;
const int *pi = pi1; //ok
*pi = j; //error,*pi 不可变,不能更改指针的间接引用形式
pi = &j; //ok,pi可变
pi = &b; //ok,pi可变
pi++; //ok
--pi; //ok
由此可见，pi是变量，可以赋值常量和变量的值,正如一个整型变量可赋整型数和整型变量一样
.const修饰的不是指针本身，而是其间接引用，=号两边的类型不必严格匹配，
如：const int* pi = &a;
中，pi的类型为int*,而&a的类型为const int* const,
只要其中含有int* 就可以。又如：const int *pi = &j;
中，pi的类型为int*,而&j的类型为int* const,它向pi赋值并无大碍。
(3)const修饰指针本身和指针所指的变量(或对象)
设有指针p,此种情形下,p和*p都不可变.举例如下:
const int* const pi = &a;
//or int const* const pi = &a;
//将const pi看作一体,就与(2)所述相同,只是要求pi必须为const,
正如上所说，=号两边的类型不必严格匹配，
但必须含有int*, &a的类型为const int* const,含有int*, 所以可以赋值。
const int* const pi = &i; //ok, &i类型为int* const,含有int*, 可赋值。
const int *pi1 = &j;
const int *const pi = pi1; //ok, pi1类型为int*
pi = &b; //error, pi不可变
pi = &j; //error, pi不可变
*pi = b; //error, *pi不可变
*pi = j; //error, *pi不可变
pi++; //error ，pi不可变
++i; //ok, =号右边的变量(或对象)与所修饰的变量无关
a--; //error, a为const
这种情况，跟以上两种情形有联系。对const int* const pi = &a;我们可以这样看：
const int*( const pi )= &a;(仅仅是表达需要)，将const pi看作一体，就与上述分类(2)符合。
只要含有int*便可.
2.const修饰引用
这种情况比较简单，没有象修饰指针那样繁复，因为引用和引用对象是一体的，
所以引用被const修饰只有一种类型。
const修饰引用,引用本身不可变,但引用的变量(或对象)可以改变.例如:
const int& ri = a; //or int const & ri = a; ok, ri 本身是常量,引用不区分类型
const int& ri = i; //ok,引用不区分类型
ri++; //error, ri为常量,不可变
i++; //ok,=右边的变量与引用无关
ri=b; //error, ri为常量
i=j; //ok,=右边的变量与引用无关
int & const ri = i; //error,不存在这种形式,没有意义
3.const修饰指针的引用
引用只是个别名,这里与修饰指针类似,又分为三种情况:
(1)
先给个例子：
const int *pi = &a;
const int *&ri = pi;
//or int const *&ri = pi;
引用是引用对象的别名，正因为如此，ri是pi的别名，所以ri的类型必须与pi完全一致才行。
这里pi的类型为int*,ri的类型也为int*，赋值可行。若const int *&ri = &a;正不正确？
分析一下就知晓。
ri类型为int*,&a的类型则为const int* const不匹配。
const int *&ri = &i; //error,类型不匹配，一为int*,一为int* const
ri = &a; //ok
ri = &i; //ok
const int *pi1=&a;
const int *pi2=&i;
ri = pi1; //ok
ri = pi2; //ok
*ri = i; //error
*ri = a; //error
注意这与1-(2)的区别.
(2)
用例子说明:
int *const &ri = &i;
去掉ri左边的&号,则为int *const ri,因为ri是别名,故ri的类型应与赋值的数类型一致,ri类型为
int *const,&i为int *const,可以这么做.
int *const &ri = pi; //error,类型不合,一为int *const ,一为int *
int *const &ri = &a; //error,类型不合,一为int *const,一为const int* const
(*ri)++; //ok
i++; //ok
ri = &i; //error
这种情况下,ri为常量,不可更改.
(3)
用例子说明：
const int* pi = &j;
const int* const &ri = pi; //or int const * const &ri = pi;ok
const int* const &ri = &i; //ok
ri是pi的别名，pi的类型应与ri一致。拿掉&，得const int* const ri ，把const ri看作一体,
很容易得出ri的类型信息，就象前面2-(3)所讨论的一样，可以得到赋给ri的只要含有类型int* 即可。
pi的类型为int*,&i的类型为int* const ,可以这么做.
const int * const &ri = &a; //ok
ri++; //error
*ri = 6; //error
言尽于此,希望对初学者有所助益!
const修饰的指针的用法解析
const修饰的指针的用法解析
今天看到了三个用const修饰的二级指针const char **p; char *const *p以及char **const p;由于我对这几个还不太熟悉,所以打算用一个测试程序来试试他们的作用, 顺便对const修饰的一级指针也探讨一下.
下面是我本次测试的程序 :
#include
int main(int argc, const char *argv[])
{
char a1[2] = { 15,25 };
char a2[2][3] = { 10, 20, 30, 50, 60, 70};
const char *p1;
char *const p2 = a1; //p2只能在定义的时候进行初始化
char const *p3; //跟"const char *p1"一样
char *p4;
const char **p11;
char *const *p22; //指向"char *const"的指针
char **const p33 = &p4; //只能在定义的时候进行初始化
p1 = a1;
//p2 = a1; //出错，不能向只读变量赋值
p3 = a1;
p4 = a1;
*p1 ++;
//(*p1) ++; //错误：令只读位置'*p1'自增
*p3 ++;
//(*p3) ++; //错误：令只读位置'*p3'自增
//*p2 ++; //出错，令只读变量自增
(*p2) ++;
printf("*p1 = %d\n", *p1); //25
printf("*p3 = %d\n", *p3); //25
printf("*p2 = %d\n", *p2); //16
p1 = a2[0];
p11 = &p1;
printf("**p11 = %d\n", **p11); //10
(*p2) ++;
**p11 ++; //*(*p11 ++);
//*p11 指向p1的下一个地址, 即 p2
printf("**p11 = %d\n", **p11); //17
*(*p11)++;
printf("**p11 = %d\n", **p11);
//(**p11) ++; //错误：令只读位置'**p11'自增
p22 = &p2;
printf("**p22 = %d\n", **p22);
(**p22) ++;
printf("**p22 = %d\n", **p22);
//*(*p22) ++; //错误：令只读位置'*p22'自增
**(p22 ++);
printf("**p22 = %d\n", **p22);
//p33 = &p4; //错误：向只读变量'p33'赋值
(**p33) ++;
printf("**p33 = %d\n", **p33);
*(*p33) ++;
printf("**p33 = %d\n", **p33);
return 0;
}
上面这个例子我就用了两个简单的数组来测试, 由这个例子我们可以明显地看出:
const char *p1 与char const *p3功能一样, 都是”ｐ的指向可以被改变，但是ｐ所指向的内容不能被改变”
char *const p2 的作用是”p2的指向不能被改变, 只能在定义的时候进行初始化, 但p2的值可以被改变”
char **const p11其实就是指向”const char *”的指针, (*p11)的值即(p1)的值, 所以也是不能改变的, 但是p11的指向可以被改变
char *const *p22是指向”char * const ”的指针, (*p22)的值即(p2)的值有一样的特性, 但是p22的指向可以被改变
char **const p33是指向”char const ”类型的指针, 它只能在定义的时候进行初始化, 他的指向不可以被改变, (*p33)即p4, 其指向以及所指向的值都是可以改变的.
const修饰符
当你想阻止一个变量被改变，可能会用到const关键字。在你给一个变量加上const修饰符的同时，通常需要对它进行初始化，因为以后的任何时候你将没有机会再去改变它。例如：
const int n=5;
int const m=10;
上述两个变量n和m其实是同一种类型的--都是const int（整形恒量）。因为C++标准规定，const关键字放在类型或变量名之前等价的。我个人更喜欢第一种声明方式，因为它更突出了const修饰符的作用。
当const与指针一起使用时，容易让人感到迷惑。例如，我们来看一下下面的p 和q的声明：
const int *p;
int const *q;
他们当中哪一个代表const int类型的指针（const直接修饰int），哪一个代表int类型的const指针（const直接修饰指针）？实际上，p和q都被声明为const int类型的指针。而int类型的const指针应该这样声明：
int * const r= &n; // n has been declared as an int
这里，p和q都是指向const int类型的指针，也就是说，你在以后的程序里不能改变*p的值。而r是一个const指针，它在声明的时候被初始化指向变量n （即r=&n;）之后，r的值将不再允许被改变（但*r的值可以改变）。
组合上述两种const修饰的情况，我们来声明一个指向const int类型的const 指针，如下：
const int * const p=&n // n has been declared as const int
C++中const修饰指针探讨
在C++里，const修饰指针有以下三种情况
（1）const int *p; const在类型前，称指向常量的指针，可以这样理解它的功能，因为const在int前，所以p指向的这个int变量对于*p来说是const的，即不能通过*p改变这个变量的值，但是变量本身可以随便改变自己的值。另外也可以改变p的指向。
例：
int x=2;
int y=3;
const int *p=&x;
*p=4; //错误，不能通过*p改变变量的值
x=4; //可以，x不是一个常量，可以改变自己的值
*p=&y; //可以，指针p本身不是一个常量，可以改变p的指向。
（2）int * const q; const在指针q的前面，叫常量指针，也就是说指针q本身是个常量，不能改变q的指向。但是可以通过*q改变所指向变量的值。
例：
int x=2;
int y=3;
int * const q=&x; //注：因为指针q是常量，在声明时就应该初始化。
*q=4; //可以
x=4; //可以，x不是一个常量，可以改变自己的值
*q=&y; //错误，指针q本身是一个常量，不能改变它的指向。
（3）const int * const pq; 这是前两种的结合，叫指向常量的常量指针。功能也是前两者的结合，即不能改变pq的指向，也不能通过*pq改变所以变量的值。
例：
int x=2;
int y=3;
const int * const pq=&x;
*pq=4; //不可以，不能通过*pq改变所指变量的指。
x=4; //可以，x不是一个常量，可以改变自己的值
*pq=&y; //错误，指针pq本身是一个常量，不能改变它的指向。
总结：从上面可以看出，不论那种情况，变量本身都是可以改变自己的值的，除非变量本身就是声明成常量（const int x=2;）。区别三种情况关键就是看const在类型前还是在指针前，在类型前，不能通过*p改变变量的值，在指针前不能改变指针的指向，且在声明时就要初始化。
常见标点符号的用法归纳 一、常见的标点符号 标点符号是辅助文字记录语言的符号，是书面语的有机组成部分，用来表示停顿、语气以及词语的性质和作用。常见的标点符号有16种，分为点号和标号两大类。 1、点号 点号的作用在于点断，主要表示说话时的停顿和语气。点号又分为句内点号和句外点号。句内点号用在句内，表示句内各种不同性质的停顿，有顿号(、)、逗号（，）、分号（；）、冒号（：）4种；句末点号用在句末，表示句末的停顿，有句号（。）、问号（？）、叹号（！）3种。 各种点号的停顿时间的长短排列如下：、﹤，﹤：；﹤。？！ 2、标号 标号的作用在于标明，主要标明语句的性质和作用。常见的标号有9种，即：引号（“”）、括号（（））、破折号（——）、省略号（……）、着重号（.）、连接号（—）、间隔号（.）、书名号（《》）和专名号（____） 二、常见标点符号的用法归纳 1、顿号（句子内部并列词语或短语的停顿） 1) 数字并列表省略时用顿号，表概数时不用顿号。 如：三年级二、三班的同学今天下午劳动两三节课。 （表省略）（表概数） 2）停顿较短的并列成分（如：锅碗瓢盆交响曲）或集合词语（如：工农兵中小学生公安干警）之间不用顿号。 3）并列词语之间带有“啊”“哇”“啦”“呀”等语气助词时不用顿号，改用逗号。 如：妈妈经常给我讲她纺线啊，织布啊，做军鞋啊。 4）并列的分句做句子的成分时，使用顿号；各自独立成句时则使用逗号。 如：难道说工期紧、任务重、难度大，就可以不顾工程的质量而随意改变设计方案吗？（作句子的成分） 今年春季，这个省……改道工程，任务重，工程难，规模大。 （各自独立成句） 5）如果大的并列成分里包含着小的并列成分时，那么大并列用逗号，小并列用顿号。 如：克隆羊、克隆牛的诞生，“神舟的五号的发射、回收，标示着我国科学发展的新水平。 小并列大并列小并列 2、逗号（略） 3、分号（复句内部并列分句的停顿） 1）复句内并列分句的停顿使用分号。 如：如实地反映客观事物，反映正确就是客观的；反之，就是不科学的。（前后正反对照，构成并列，当使用分号）
const int* a = &b 和const* int a = &b的区别收藏 如果const关键字不涉及到指针，我们很好理解，下面是涉及到指针的情况： int b = 500; const int* a = &b; [1] int const *a = &b; [2] int* const a = &b; [3] const int* const a = &b; [4] 如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。不知道，也没关系，我们可以参考《Effective c++》Item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。另外const 的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法： A& operator=(const A& a); void fun0(const A* a ); void fun1( ) const; // fun1( ) 为类成员函数 const A fun2( ); --------------------------------------------------------------------------------------------------------------------------------------------- const int * pi 、int const * pi与int * const pi及其操作 （本贴已经做了重大修改） 1 从const int i 说起
关键字const有什么含意？ 我只要一听到被面试者说：“const意味着常数”，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。） 如果应试者能正确回答这个问题，我将问他一个附加的问题： 下面的声明都是什么意思？ const int a; int const a; const int *a; int * const a; int const * a const; /******/ 前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由： ?; 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。） ?; 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。 ?; 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。 Volatile 8. 关键字volatile有什么含意?并给出三个不同的例子。 一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子： ?; 并行设备的硬件寄存器（如：状态寄存器） ?; 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables) ?; 多线程应用中被几个任务共享的变量 回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。 假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile 完全的重要性。 ?; 一个参数既可以是const还可以是volatile吗？解释为什么。 ?; 一个指针可以是volatile 吗？解释为什么。
Unit5 Grammar Inversion（倒装） 英语部分倒装用法归纳（Partial Inversion） 1. 否定副词位于句首时的倒装 在正式文体中，never, seldom, rarely, little, hardly, scarcely, no sooner, no longer, nowhere 等含有否定意义的副词若位于句首，则其后要用部分倒装： I shall never forgive him. / Never shall I forgive him. 我永远不会宽恕他。 He seldom goes out for dinner. / Seldom does he go out for dinner. 他很少出去吃饭。 She hardly has time to listen to music. / Hardly does she have time to listen to music. 她几乎没时间听音乐。 He little realizes how important this meeting is. / Little does he realize how important this meeting is. 他不甚明白这个会议的重要性。 We had no sooner reached the airport than the plane took off. / No sooner had we reached the airport than the plane took off. 我们刚到机场,飞机就起飞了。 【注意】 (1)对于not…until句型，当not until…位于句首时，其后的主句要用倒装语序： He didn’t leave the r oom until the rain stopped. / Not until the rain stopped did he leave the room. 雨停了之后他才离开这房间。 (2)某些起副词作用的介词短语，由于含有否定词，若位于句首，其后要用部分倒装： On no accounts must this switch be touched. 这个开关是绝不能触摸的。 In [Under] no circumstances will I lend money to him.无论如何我也不会再借钱给他了。 但是，in no time(立即，马上)位于句首时，其后无需用倒装语序： In no time he worked out the problem. 他马上就算出了那道题。 2.“only+状语”位于句首时的倒装 当一个状语受副词only的修饰且置于句首时，其后用部分倒装语序： Only then did he realize that he was wrong. 到那时他才意识到他错了。 Only in this way are you able to do it well. 你只有用这种方法才能把它做好。 Only when he returned home did he realize what had happened. 当他回到家里时，才知道出了什么事。 3. “so+adj. / adv.”位于句首时的倒装 副词so后接形容词或副词位于句首时，其后用部分倒装： So cold was the weather that we had to stay at home. 天气太冷，我们只好呆在家里。 So fast does light travel that we can hardly imagine its speed. 光速很快，我们几乎没法想像它的速度。 So sudden was the attack that we had no time to escape. 袭击来得非常突然，我们来不及逃跑。 4.“so+助动词+主语”倒装 当要表示前面提出的某一肯定的情况也同样适合于后者，通常就要用“So+助动词+主语”这种倒装结构： You are young and so am I. 你年轻，我也年轻。 She likes music and so do I. 她喜欢音乐，我也喜欢。
--------------------------CONST--------------------------------------- const应用: 一、对于基本声明 const int r=100;//标准const变量声明加初始化，编译器经过类型检查后直接用100在编译时替换。 二、对于指针 1. int x=10; const int *r=&x; //指针指向的内容是常量,r指向的内容不能够通过r改变,但如果是非const,内容可以通过自己改变,而且r指针可以改变,可以指向其它的整形. //*r=*r+1;NO //x++;YES //r=&y;YES 2. int const *r=&x; 与1完全相同 3. int * const r=&x; //指针指向是常量,不能修改去指向其它内容,但指向的内容可以修改 //r=&y;NO //*r=*r+1;YES //x++;YES 4.const int * const r=&x; //综合1、3用法，r是一个指向常量的常量型指针,指针指向不能改变,指针内容不能改变,内容可以自身改变 //r=&y;NO //*r=*r+1;NO //x++;YES 三、对于类型检查 可以把非const对象赋予const指针,这样就不能改变.但是不能把const赋给非const,除非先强制转换 const int x=100; int *p=(int*)&x; *p++; 四、对于函数 1.void Fuction1(const int r); //此处为参数传递const值，意义是变量初值不能被函数改变 2.const int Fuction1 (int); //此处返回const值，意思指返回的原函数里的变量的初值不能被修改，但是函数按值返回的这个变量被制成副本，能不能被修改就没有了意义，它可以被赋给任何的const或非const类型变量，完全不需要加上这个const关键字。 3.Class CX; //内部有构造函数，声明如CX(int r =0) CX Fuction1 () { return CX(); } const CX Fuction2 () { return CX(); } Fuction1() = CX(1); //没有问题，可以作为左值调用 Fuction2() = CX(1); //编译错误，const返回值禁止作为左值调用。 4.函数中指针的const传递和返回： int F1 (const char *pstr); //作为传递的时候使用const修饰可以保证不会通过这个指针来修改传递参数的初值 const char *F2();//意义是函数返回的指针指向的对象是一个const对象，它必须赋给一个同样是指向const对象的指针 const char * const F3(); //比上面多了一个const，这个const的意义只是在他被用作左值时有效，它表明了这个指针除了指向const对象外，它本身也不能被修改，所以就不能当作左值来处理。 五、对于类 1.首先，对于const的成员变量，只能在构造函数里使用初始化成员列表来初始化，试图在构造函数体内进行初始化const成员变量会引起编译错误。初始化成员列表形如：X:: X ( int ir ): r(ir) {} //假设r是类X的const成员变量 注意：类的构造和析构函数都不能是const函数。 2.建立了一个const成员函数，但仍然想用这个函数改变对象内部的数据。(函数不能修改类的数据成员)
IF的用法 if是英语中出现频率很高的连词，并且它的用法也很多。学生感到很难掌握，为了让同学们更多更好地了解其用法及其语法功能。现结合教学中遇到的情况，予以归纳，以供参考。 一、if作为连词，引导条件状语从句，它表示的意思是“假如”“如果”等。在复合句中如果主句用将 来时，则if引导的状语从句用一般现在时。例如： 1. If itdoesn’train, we will go to the park next Sunday. 如果天不下雨，下周星期天我们将去公园。 2. If you ask him，he will help you．如果你求他，他将会帮助你。 二、if还可以引导让步状语从句。这时if当作“即使是”，“虽说”解。例如： 1. If she’s poor，at least she’s honest．虽说她很穷，但至少她还是诚实的。 2. If I am wrong，you are wrong，too．即使说我错了，那么你也不对。 3. I’ll do it, even if it takes me all the afternoon．虽然会花费我一下午的时间，我还是要做这事。 三、if作为连词还可以引导宾语从句。引导宾语从句时和whether意思相同。例如： 1. Lily asked if ／whether she liked it. 莉莉问她是否喜欢它。 2. She asked if ／whether they had a cotton one．她问是否他们有一件棉织的。 四、if引导时间状语从句，当if做“当”或“无论何时”解而不含有条件之义时，if从句中的时态与主句中的时态相同。例如： 1. If youmix yellow and blue，you get green．你将黄色与蓝色混合，便会得到绿色。 2. If she wants the servant，she rings the bell．每当她需要仆人时，她便按铃。 五、if后接否定动词，用于感叹句中，表示沮丧、惊奇等。例如： I. Well，if I haven’t left my false teeth at home!真倒霉，我把假牙丢在家里了! 2. And if he didn’t try to kn ock me down!(What do you think he did!He tried knock me down!)你猜他想做什么?他想把我撞倒! 六、用于虚拟语气中，if从句中用过去式，表示不可能实现，大概不会实现或提出作为考虑的假定条件。例如： 1. If you were a bird, you could fly.假使你是只鸟，你便会飞了。 2. If I asked him(if I were to ask him) for a loan，would he agree?如果我向他借贷，他会答应吗? 另外，if从句中用过去完成式，表示过去未实现的条件(例如由于不可能实现或某人之未能实行)。例如： 1. If they had startedearlier，they would have arrivedin time．要是他们早些动身，他们便可及时到达了。 2. If they had not started when they did，they would not be here now．如果他们那时不动身，现在他们就不会在此地了。 第三，在文学体栽中，if有时可省略，然后将主语与所用的限定动词(尤其是were，had，should)倒置。例如： 1. Should it (=if it should)be necessary，I will go. 倘若有必要，我会去的。 2. Were I(=if I were) in your place，I would do the same ．如果我处于你的位置，我也会这样干的。 3. Had I(=if I had)known earlier，I would come．如果我早一点知道，我就会来。 七、if与其它一些介词的连用。
const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。类型声明中const用来修饰一个常量，有如下两种写法，那么，请问，下面分别用const限定不可变的内容是什么? 1)、const在前面 const int nValue；//nValue是const const char *pContent; //*pContent是const, pContent可变 const (char *) pContent;//pContent是const,*pContent可变 char* const pContent; //pContent是const,*pContent可变 const char* const pContent; //pContent和*pContent都是const 2)、const在后面，与上面的声明对等 int const nValue；// nValue是const char const * pContent;// *pContent是const, pContent可变 (char *) const pContent;//pContent是const,*pContent可变 char* const pContent;// pContent是const,*pContent可变 char const* const pContent;// pContent和*pContent都是const 答案与分析： const和指针一起使用是C语言中一个很常见的困惑之处，在实际开发中，特别是在看别人代码的时候，常常会因为这样而不好判断作者的意图，下面讲一下我的判断原则：当const所在代码段中不包含括号时，沿着*号划一条线，如果const 位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。你可以根据这个规则来看上面声明的实际意义，相信定会一目了然。
标点符号 知识要点： 标点符号是书面语言的有机组成部分，是书面语言不可缺少的辅助工具。标点符号的主要作用有三点：1．表示停顿；2．表示语气；3．表示词语的性质和作用。现在通行的标点符号有l6种，分为点号和标号两大类。点号包括：顿号(、)、逗号(，)、分号(；)、句号（。）、问号(?)、叹号(!)和冒号(：)。而标号则包括：破折号(——)、括号(( ))、省略号（……)、书名号(《》)、引号(“”)等。 答题注意： 1、标点符号是书面语里用来表示停顿、语调以及词语性质和作用的符号。虽然它只是一个小符号，作用却非常大，一定要认真读题，什么样的语气就相应地用什么样的标点符号。 2、给一段话加标点，难度较大，首先要认真地读这一段话看一看一共有几句话．每句话是什么意思，使用的是怎样的语气，然后再动手加标点符号，最后再读一读，检查标点符号使用得是否恰当、正确。 方法指津： 小学5～6年级与初中阶段要求掌握的常用标点符号大体一致，只是题型有变化，难度有所提高。在解题时要注意以下几个方面： 1．建立标点符号用法表，熟悉掌握常用标点符号的用法。无论是主观题，还是客观题，熟悉并掌握常用标点符号的用法，是准确解答标点符号题的基础。 2．熟记各种标点符号的位置，规范使用标点符号。如：标点符号由点号与标号组成，点号分为句中点号和句末点号。其中句中点号由顿号、分号、逗号组成，这三种点号均表示一个句子内部的停顿。顿号表示词语之问的停顿，一般应是两个或以上的词语之间，停顿时间最短；逗号表示一个句子内的一般性停顿，可以是词语、短语或句子内部的分句，停顿时问稍长；分号则用于复句内部并列的分句之间或排比句中并列的分句之间，停顿的时间比逗号更长。运用时，应先用停顿短的逗号，再用停顿长的分号，不能乱了秩序，只有在分行列举的各项之间，才能直接用分号。又如：七种点号都占一个字的位置，通常点在紧靠文字右边偏下，不能用在一行之首，引号、括号、书名号都标在文字前后，各占一个字位置。破折号和省略号占两个字的位置，都标在正中。连接号占一个字的位置，着重号标在字的下面，间隔号写在格子正中。知晓了这些内容，才能规范使用标点符号，为识破标点使用的正误打下基础。 3．总结、积累标点符号使用的特点、规律，以简驭繁。事物总是有规律的，标点符号也不例外。如冒号的使用就有以下规律：一是冒号不能连用，在同一句子中，冒号一般只用一个，否则便会面目不清，必须将其中一个改为逗号；二是冒号后面揭示范围不清楚。特别是冒号与引号连用时，一定要分清冒号提示的范围，如果提示的是全部，句末的句号应在引号之外；如果提示的仅引号内的部分，那么或将冒号改为逗号，或将逗号改为引号内句号。 4．对易错标点要反复训练，定期复习巩固。有些标点在使用中常常被误用，如顿号、分号、逗号的误用，冒号的误用，句号、叹号、问号的误用等。还有不同标点间的连用、套用容易出错，比如引号的使用．因为引语与“某某说”之间位置不同，标点符号也就不同。“说”在前，“引语”在后，“说”后用冒号；“说”在“引语”中间，“说”后用逗号；“说”在“引语”之后，“说”后用句号。如果区分不明，则易导致标号误用。因此，我们在平时的学习实践中一定要反复训练，不断强化巩固。
精心整理1.(表示条件)如果,主句用将来时，if从句用现在时表示将来Hewillcomeifyouinvitehim. 如果你请他,他会来的。 2.(表示虚拟)假如,要是 1 a. b. 句型：条件从句主句 过去完成时should(would)have+过去分词 Ifshehadworkedharder,shewouldhavesucceeded. Thericewouldnothavebeenburntifyouhadbeenmorecareful.
IfmylawyerhadbeenherelastSaturday,hewouldhavepreventedmefromgoing. Ifhehadcomeyesterday,Ishould/wouldhavetoldhimaboutit. 含义：Hedidnotcomeyesterday,soIdidnottellhimaboutit. c. were+ Ifyousucceeded,everythingwouldbeallright. Ifyoushouldsucceed,everythingwouldbeallright. Ifyouweretosucceed,everythingwouldbeallright.
3.是否=whether连接宾语从句 Iwonderifsheisill. 不知她是否病了。 连接词conj. 1.( 2.( 3.( 4.是否 不知她是否病了。 5.(表示因果关系)每一次...的时候(总是会) IfIfeelanydoubt,Iinquire. 我一感到有疑问就随时询问。 if作为连词的时候，一般用于条件状语从句或者是宾语从句或让步状语从句
what用法总结 温馨提示:what用法很多，对专升本有用的我已经用红色字体显示，由于部分同学考研可能要用到，把几乎所有用法都附上了。 what的用法是各种类型英语科测试的热点，what的用法灵活多变，出题花样翻新，只有对其有一个全面的掌握，才能灵活运用。本文以2006年的两道高考题为例，总结what的用法，希望能让同学们对它有一个全面的了解。 The shopkeeper did not want to sell for _____ he thought was not enough.（2006山东卷第26题） A. where B. how C. what D. which 答案：C Great changes have taken place in that school. It is no longer _____ it was 20 years ago, _____ it was so poorly equipped.（2006安徽卷第32题） A. what; when B. that; which C. what; which D. which; that 答案：A. 上述两题中的what都是关系代词，一般含义是“the thing that”。第一题中what 的意思是“the price that”，引导宾语从句；第二题中what的意思是“the school that”，引导的是表语从句。what的其他结构还有：
一、what + little 在此结构中，little是名词，强调某种东西“虽少但已是全部”，至于被强调的是什么，只能凭借上下文来判断。 例如：（1）What little he said on the subject was full of wisdom. （2）She saved what little of the money she could out of her slim salary to help her brother go to school 二、what little + 名词 此结构为上一结构的延伸，所不同的是，little在这里不是名词，而是形容词了。 例如：（1）He gave me what little money he had about him. （2）My father spent what little spare time he had in writing. 三、what + few + 名词 当被修饰的名词为可数名词时，little应换成few，含义为“仅有的几个”。 例如：（1）What few friends I have are very kind to me. （2）I will lend you what few books I can spare.
1. If you eat my food, I won’t talk to you. (P58) 2. I will die , I don’t have food, (P58) 3. What shall we do if it rains tomorrow? 5. She asked me if I was fond of music. 她问我是否喜欢音乐。 6. Can you tell me if they’re planning to come? 你能告诉我他们是否打算过来吗？ 7. I don’t know if she’s coming. 我不知道她是否会来。 ◇相关词组 ☆if you want/like如果你愿意的话 You can come and stay with us if you want. ☆if so如果是的话 Are you planning to return to work, and if so, who is going to look after the baby? ☆if not如果不是的话 Has anyone dealt with the technical problems? And if not, why not?☆if necessary/if possible 如果必要/可能的话 We are ready to fight for our rights if necessary. I should like to be back here by 10:30 if possible. ☆even if即使 I’d rather never sell this painting, even if they offered me a million dollars. ☆what if 要是……，那怎么办？如果……那会怎样？ What if the boss walked in here now and saw us? ☆as if好像是…… She always talks to me as if she was my sister. ◇相关练习 动词填空： 1. If it ______ (be) sunny tomorrow, I ______( walk) to school . 2. We ________ (not have ) our sports meeting if the
或许还有不少人对于const修饰符理解的并不深刻，都只是停留在一个比较浅的层面上，仅仅是在读别人代码的时候看到了const修饰符的使用，自己的写代码的过中从未使用过，所以自然对于const修饰符比较陌生。那么到底什么是const 修饰符，我们在自己编写C语言代码的过程中又该如何有效的使用const修饰符呢，现在让我们来学习下const修饰符的使用。 const在C语言中算是一个比较新的描述符，我们称之为常量修饰符，即就是说其所修饰的对象为常量。当你代码中想要设法阻止一个变量被改变，那么这个时候可以选择使用const关键字。在你给一个变量加上const修饰符的同时，通常需要对它进行初始化，在之后的程序中就不能再去改变它。 可能有的人会有一个疑问，我们不是有在C中有预处理指令#define VariableNameVariableValue可以很方便地进行值替代，干嘛还要引入const修饰符呢?!这是因为预处理语句虽然可以很方便的进行值得替代，但它有个比较致命的缺点，即预处理语句仅仅只是简单值替代，缺乏类型的检测机制。这样预处理语句就不能享受C编译器严格类型检查的好处，正是由于这样，使得它的使用存在着一系列的隐患和局限性。 在讲解const修饰符之前，我们在此首先给出const修饰符的几个典型作用： 1. const类型定义：指明变量或对象的值是不能被更新,引入目的是为了取代预编译指令 2. 可以保护被修饰的东西，防止意外的修改，增强程序的健壮性; 3. 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。 4. 可以节省空间，避免不必要的内存分配。 接下来看看具体的使用。 一、const修饰符在函数体内修饰局部变量。 constint n=5; 和 intconst n=5;
partly的用法总结大全 partly的意思是什么呢?partly的用法是怎样的呢，今天给大家带来了parcel的用法,希望能够帮助到大家，一起来学习吧。 partly的意思 adv. 在一定程度上,部分地,不完全地,半 partly用法 partly可以用作副词 partly用作副词指“部分地,不完全地”,修饰形容词常置于其前。常用于partly...partly...结构。 partly无比较级和最高级形式。 partly用作副词的用法例句 You have introduced a partly random component.你介绍了一个在一定程度上属于偶然的成分。 The transformation is partly due to demographics.这一变化一定程度上是源于人口的变化。 Their energy is partly dissipated.它们的能量被部分地消耗掉。
partly双语例句 1.This is partly a political and partly a legal question.这个问题部分是政治问题, 部分是法律问题。 2.Farming is partly subsidised by the government.农业得到政府的部分资助。 3.Their company sell partly to foreign markets.他们公司部分向国外市场销售。 4.Leaves scale-like, distichous, equitant, sometimes linear or partly linear.叶鳞片状，2列，套折，有时线形的或部分线形。 5.The delay is partly explicable by the road works.延误的部份原因是道路施工。 6.I believe what he has said is partly true.我相信他刚才说的话一部分是真实的。 7.The sale of ice cream is partly determined by the weather.冰淇淋的销量部分取决于天气。 8.Maturate partly in French oak barrique and partly in Slovenian oak casks for about 12-15 months.之后，一部分在法国橡木桶里醇化，一部分在斯洛文尼亚橡木桶里醇化，大致需要12-15个月。
whether,if if和whether通用，都表示“是否”的意思。一般来说，后者比较正式，在口语中前者常用来代替后者。但两者有时具有不同的暗示。用whether时，正反两面的选择意义较强，问话人并不在意回答是肯定还是否定；而用if时，则比较强调单方面，即正面，问话人希望得到肯定的回答。另外，还要注意以下几点： 一、whether和if都可以与or not连用；但写在一起时，只能用whether，不能用if。如： I don't care whether (或if) it will rain or not． I don't care whether or not it will rain. (不用if) 二、在引导宾语从句时，应注意： 1、表示“是否”时，两词都能引导宾语从句。 I wonder if/whether you can examine him now． 2、宾语从句移置句首时，用whether，不用if。
Whether it is true or not，I can't say． 3、宾语从句为否定形式时，通常用if，而不用whether。 I asked Tom if Mary wouldn’t come． 4、作discuss等词的宾语，用whether不用if。 We discussed whether we should buy the gift for him． 三、在下列情况下，只能用whether，不能用if。 1、与不定式连用时，只能用whether． He can't decide whether to accept or refuse． 2、在介词后，只能用whether。 Everything depends on whether he is ready． 3、在名词后作同位语时，只能用whether。
1.const的用法： 看到const 关键字，C++程序员首先想到的可能是const 常量。这可不是良好的条件反射。如果只知道用const 定义常量，那么相当于把火药仅用于制作鞭炮。const 更大的魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。 const 是constant 的缩写，“恒定不变”的意思。被const 修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多C++程序设计书籍建议：“Use const whenever you need”。 1.用const 修饰函数的参数 如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const 修饰，否则该参数将失去输出功能。const 只能修饰输入参数： 如果输入参数采用“指针传递”，那么加const 修饰可以防止意外地改动该指针，起到保护作用。 例如StringCopy 函数： void StringCopy(char *strDestination, const char *strSource); 其中strSource 是输入参数，strDestination 是输出参数。给strSource 加上const修饰后，如果函数体内的语句试图改动strSource 的内容，编译器将指出错误。 如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。 例如不要将函数void Func1(int x) 写成void Func1(const int x)。 同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。 对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。 为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func(A & a) 存在一个缺点： “引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func(const A &a)。 以此类推，是否应将void Func(int x) 改写为void Func(const int &x)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。 问题是如此的缠绵，我只好将“const &”修饰输入参数的用法总结一下。 对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。 对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。
一、if作为连词，引导条件状语从句，它表示的意思是“假如”“如果”等。在复合句中如果主句用将来时，则if引导的状语从句用一般现在时。例如： 1. If itdoesn’train, we will go to the park next Sunday. 如果天不下雨，下周星期天我们将去公园。 2. If you ask him，he will help you．如果你求他，他将会帮助你。 二、if还可以引导让步状语从句。这时if当作“即使是”，“虽说”解。例如： 1. If she’s p oor，at least she’s honest．虽说她很穷，但至少她还是诚实的。 2. If I am wrong，you are wrong，too．即使说我错了，那么你也不对。 3. I’ll do it, even if it takes me all the afternoon．虽然会花费我一下午的时间，我还是要做这事。 三、if作为连词还可以引导宾语从句。引导宾语从句时和whether意思相同。例如： 1. Lily asked if ／whether she liked it. 莉莉问她是否喜欢它。 2. She asked if ／whether they had a cotton one．她问是否他们有一件棉织的。 四、if引导时间状语从句，当if做“当”或“无论何时”解而不含有条件之义时，if从句中的时态与主句中的时态相同。例如： 1. If youmix yellow and blue，you get green．你将黄色与蓝色混合，便会得到绿色。 2. If she wants the servant，she rings the bell．每当她需要仆人时，她便按铃。 五、if后接否定动词，用于感叹句中，表示沮丧、惊奇等。例如： I. Well，if I haven’t left my false teeth at home!真倒霉，我把假牙丢在家里了! 2. And if he didn’t try to knock me down!(What do you think he did!He tried knock me down!) 六、用于虚拟语气中，if从句中用过去式，表示不可能实现，大概不会实现或提出作为考虑的假定条件。例如： 1. If you were a bird, you could fly.假使你是只鸟，你便会飞了。 2. If I asked him(if I were to ask him) for a loan，would he agree?如果我向他借贷，他会答应吗? 七、if从句中用过去完成式，表示过去未实现的条件(例如由于不可能实现或某人之未能实行)。 1. If they had startedearlier，they would have arrivedin time． If they had not started when they did，they would not be here now． 第三，在文学体栽中，if有时可省略，然后将主语与所用的限定动词(尤其是were，had，should)倒置。例如： 1. Should it (=if it should)be necessary，I will go. 倘若有必要，我会去的。 2. Were I(=if I were) in your place，I would do the same ． 3. Had I(=if I had)known earlier，I would come．如果我早一点知道，我就会来。 八、if与其它一些介词的连用。 （1）as与if连用，它的意思是：“仿佛、好像”同样引导从句。例如： 1. It isn’t as if we are rich．(We are not rich．)我们不像富有的样子。(即我们不富有) 2. It isn’t as if he doesn’t know the ruler．(i．e．He does know the rulers．) （2）as if还可以引导感叹句。例如： As if I would allow it!(i．e．I would certainly not allow it!) （3）if与only连用。常表示愿望或一个未实现的条件，尤其用于感叹句中。例如： 1. If only he arrives in time!他若能及时到达就好了! 2. If only she would marry me!但愿她能嫁给我！ 3. If only she had known about it!（But she didn’t know.） 1.if 可引导状语从句----“如果...,假使...”[就现在,过去,未来可能实现之事加以推测时] If you are tired, we will go straight home 如果你疲倦了,我们就直接回家 If you have finished reading this book, please return it to me Do you mind if I open the window? 如果我打开窗子,你介意吗?