const用法详解
面向对象是C++的重要特性.
但是c++在c的基础上新增加的几点优化也是很耀眼的
就const直接可以取代c中的#define
以下几点很重要,学不好后果也也很严重
const
1. 限定符声明变量只能被读
const int i=5;
int j=0;
...
i=j; //非法，导致编译错误
j=i; //合法
2. 必须初始化
const int i=5; //合法
const int j; //非法，导致编译错误
3. 在另一连接文件中引用const常量
extern const int i; //合法
extern const int j=10; //非法，常量不可以被再次赋值
4. 便于进行类型检查
用const方法可以使编译器对处理内容有更多了解。
#define I=10
const long &i=10; /*dapingguo提醒：由于编译器的优化，使
得在const long i=10; 时i不被分配内存，而是已10直接代入
以后的引用中，以致在以后的代码中没有错误，为达到说教效
果，特别地用&i明确地给出了i的内存分配。不过一旦你关闭所
有优化措施，即使const long i=10;也会引起后面的编译错误。*/
char h=I; //没有错
char h=i; //编译警告，可能由于数的截短带来错误赋值。
5. 可以避免不必要的内存分配
#define STRING "abcdefghijklmn\n"
const char string[]="abcdefghijklm\n";
...
printf(STRING); //为STRING分配了第一次内存
printf(string); //为string一次分配了内存，以后不再分配
...
printf(STRING); //为STRING分配了第二次内存
printf(string);
...
由于const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在
程序运行过程中只有一份拷贝，而#define定义的常量在内存中有
若干个拷贝。
6. 可以通过函数对常量进行初始化
int value();
const int i=value();
dapingguo说：假定对ROM编写程序时，由于目标代码的不可改写，
本语句将会无效，不过可以变通一下：
const int &i=value();
只要令i的地址处于ROM之外，即可实现：i通过函数初始化，而其
值有不会被修改。
7.是不是const的常量值一定不可以被修改呢？
观察以下一段代码：
const int i=0;
int *p=(int*)&i;
p=100;
通过强制类型转换，将地址赋给变量，再作修改即可以改变const常量值。
8. 请分清数值常量和指针常量，以下声明颇为玩味：
int ii=0;
const int i=0; //i是常量，i的值不会被修改
const int *p1i=&i; //指针p1i所指内容是常量，可以不初始化
int * const p2i=ⅈ //指针p2i是常量，所指内容可修改
const int * const p3i=&i; //指针p3i是常量，所指内容也是常量
p1i=ⅈ //合法
*p2i=100; //合法
关于C++中的const关键字的用法非常灵活，而使用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常量。
常见标点符号的用法归纳 一、常见的标点符号 标点符号是辅助文字记录语言的符号，是书面语的有机组成部分，用来表示停顿、语气以及词语的性质和作用。常见的标点符号有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 说起
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与其它一些介词的连用。
.net软件工程师面试题 基础题： 1.简述string[]、ArrayList、List的区别。 数组： 优点： o数组在内存中是连续存储的，索引速度非常快； o赋值和修改元素也很简单； 不足： o两个数据之间插入数据比较麻烦； o声明数组的时候，必须指明数组的长度，数组长度过长会造成内存浪费，数组的长度过短，会造成数据溢出错误。 ArrayList： 优点： https://www.doczj.com/doc/443983009.html, framework 提供的用于数据存储和检索的专用类 o大小依据存储的数据来动态扩展和收缩 o继承IList，可以方便的进行数据的添加、插入和删除 缺点： o允许插入不同类型的数据，都当做object类型处理 o数据处理时可能出现类型不匹配的错误
o存在装箱（值=》引用）拆箱的操作，会带来很大的性能损耗 List： 优点： o声明List集合时，需要声明集合内数据的对象类型 o避免了类型安全问题和装箱拆箱的性能问题 2.简述装箱和拆箱操作中的性能损耗是如何产生的。 3.简述对https://www.doczj.com/doc/443983009.html,中的事件机制的理解。 4.在一个https://www.doczj.com/doc/443983009.html,的三层结构系统中，以登录操作为例，简述在各层中如何组织代码。 5.简述相比DATASET，实体类在WEB项目中的优点与缺点。 6.简述GC是如何工作的。 Java采用VM（Virtual Machine）机制，由VM来管理程序的运行当然也包括对GC管理。90年代末期.NET出现了，.NET采用了和Java类似的方法由CLR(Common Language Runtime)来管理。 Garbage Collector（垃圾收集器，在不至于混淆的情况下也成为GC）以应用程序的root 为基础，遍历应用程序在Heap上动态分配的所有对象[2]，通过识别它们是否被引用来确定哪些对象是已经死亡的、哪些仍需要被使用。已经不再被应用程序的root或者别的对象所引用的对象就是已经死亡的对象，即所谓的垃圾，需要被回收。这就是GC工作的原理。为了实现这个原理，GC有多种算法。比较常见的算法有Reference Counting，Mark Sweep，Copy Collection等等。目前主流的虚拟系统.NET CLR，Java VM和Rotor都是采用的Mark Sweep算法。
标点符号 知识要点： 标点符号是书面语言的有机组成部分，是书面语言不可缺少的辅助工具。标点符号的主要作用有三点：1．表示停顿；2．表示语气；3．表示词语的性质和作用。现在通行的标点符号有l6种，分为点号和标号两大类。点号包括：顿号(、)、逗号(，)、分号(；)、句号（。）、问号(?)、叹号(!)和冒号(：)。而标号则包括：破折号(——)、括号(( ))、省略号（……)、书名号(《》)、引号(“”)等。 答题注意： 1、标点符号是书面语里用来表示停顿、语调以及词语性质和作用的符号。虽然它只是一个小符号，作用却非常大，一定要认真读题，什么样的语气就相应地用什么样的标点符号。 2、给一段话加标点，难度较大，首先要认真地读这一段话看一看一共有几句话．每句话是什么意思，使用的是怎样的语气，然后再动手加标点符号，最后再读一读，检查标点符号使用得是否恰当、正确。 方法指津： 小学5～6年级与初中阶段要求掌握的常用标点符号大体一致，只是题型有变化，难度有所提高。在解题时要注意以下几个方面： 1．建立标点符号用法表，熟悉掌握常用标点符号的用法。无论是主观题，还是客观题，熟悉并掌握常用标点符号的用法，是准确解答标点符号题的基础。 2．熟记各种标点符号的位置，规范使用标点符号。如：标点符号由点号与标号组成，点号分为句中点号和句末点号。其中句中点号由顿号、分号、逗号组成，这三种点号均表示一个句子内部的停顿。顿号表示词语之问的停顿，一般应是两个或以上的词语之间，停顿时间最短；逗号表示一个句子内的一般性停顿，可以是词语、短语或句子内部的分句，停顿时问稍长；分号则用于复句内部并列的分句之间或排比句中并列的分句之间，停顿的时间比逗号更长。运用时，应先用停顿短的逗号，再用停顿长的分号，不能乱了秩序，只有在分行列举的各项之间，才能直接用分号。又如：七种点号都占一个字的位置，通常点在紧靠文字右边偏下，不能用在一行之首，引号、括号、书名号都标在文字前后，各占一个字位置。破折号和省略号占两个字的位置，都标在正中。连接号占一个字的位置，着重号标在字的下面，间隔号写在格子正中。知晓了这些内容，才能规范使用标点符号，为识破标点使用的正误打下基础。 3．总结、积累标点符号使用的特点、规律，以简驭繁。事物总是有规律的，标点符号也不例外。如冒号的使用就有以下规律：一是冒号不能连用，在同一句子中，冒号一般只用一个，否则便会面目不清，必须将其中一个改为逗号；二是冒号后面揭示范围不清楚。特别是冒号与引号连用时，一定要分清冒号提示的范围，如果提示的是全部，句末的句号应在引号之外；如果提示的仅引号内的部分，那么或将冒号改为逗号，或将逗号改为引号内句号。 4．对易错标点要反复训练，定期复习巩固。有些标点在使用中常常被误用，如顿号、分号、逗号的误用，冒号的误用，句号、叹号、问号的误用等。还有不同标点间的连用、套用容易出错，比如引号的使用．因为引语与“某某说”之间位置不同，标点符号也就不同。“说”在前，“引语”在后，“说”后用冒号；“说”在“引语”中间，“说”后用逗号；“说”在“引语”之后，“说”后用句号。如果区分不明，则易导致标号误用。因此，我们在平时的学习实践中一定要反复训练，不断强化巩固。
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.(表示条件)如果,主句用将来时，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作为连词的时候，一般用于条件状语从句或者是宾语从句或让步状语从句
我们都知道，const和static readonly的确很像：通过类名而不是对象名进行访问，在程序中只读等等。在多数情况下可以混用。二者本质的区别在于，const的值是在编译期间确定的，因此只能在声明时通过常量表达式指定其值。而static readonly是在运行时计算出其值的，所以还可以通过静态构造函数来赋值。明白了这个本质区别，我们就不难看出下面的语句中static readonly和const能否互换了： 1. static readonly MyClass myins = new MyClass(); 2. static readonly MyClass myins = null; 3. static readonly B = 10; static readonly A = B * 20; 4. static readonly int [] constIntArray = new int[] {1, 2, 3}; 5. void SomeFunction() { const int a = 10; ... } 6.private static string astr="abcd"; private const string str = astr+"efg"; 1：不可以换成const。new操作符是需要执行构造函数的，所以无法在编译期间确定 2：可以换成const。我们也看到，Reference类型的常量（除了String）只能是Null。 3：可以换成const。我们可以在编译期间很明确的说，A等于200。 4：不可以换成const。道理和1是一样的，虽然看起来1,2,3的数组的确就是一个常量。5：不可以换成readonly，readonly只能用来修饰类的field，不能修饰局部变量，也不能修饰property等其他类成员。 6.错误：如果在astr前加上const或者const改为readonly即可； 总结：1.const、readonly和static readonly定义的常量，指定初始值后(包括在构造函数内指定的初始值) 将不可更改，可读不可写； 2.const定义时必须指定初始值，而readonly定义时可以不进行初始化(MS建议在定义时初始值),同时也可以在构造函数内指定初始值， 并以构造函数内指定的值为准； 3.const和static readonly定义的常量是静态的，只能由类直接访问；而readonly定义的常量是非静态的，只能由实例对象访问； 4.static readonly常量，如果在构造函数内指定初始值，则必须是静态无参构造函数； 5.const是编译时常量，readonly是运行时常量；cosnt较高效，readonly较灵活。在应用上以static readonly代替const，以平衡const在灵活性上的不足， 同时克服编译器优化cosnt性能，所带来的程序集引用不一致问题； 文章2：
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
C# 基础知识 25个常见问题（1） 2007-04-12 16:53 当初学 C# 时是找个人大概问了一下数据类型和分支语句就开始做项目了。这两天又全面的看了一下相关的基础知识（学而时习之嘛），总结了25个问题： 1.静态变量和非静态变量的区别？ 2.const 和 static readonly 区别？ 3.extern 是什么意思？ 4.abstract 是什么意思？ 5.internal 修饰符起什么作用？ 6.sealed 修饰符是干什么的？ 7.override 和 overload 的区别？ 8.什么是索引指示器？ 9.new 修饰符是起什么作用？ 10.this 关键字的含义？ 11.可以使用抽象函数重写基类中的虚函数吗？ 12.密封类可以有虚函数吗？ 13.如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后可以有几个属性访问器？如果基类中有 get 和 set 两个呢？ 14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？ 15.接口可以包含哪些成员？ 16.类和结构的区别？ 17.接口的多继承会带来哪些问题？ 18.抽象类和接口的区别？ 19.别名指示符是什么？ 20.如何释放非托管资源？ 21.P/Invoke是什么？ 22.StringBuilder 和 String 的区别？ 23.explicit 和 implicit 的含义？ 24.params 有什么用？ 25.什么是反射？ 以下是我做的一份参考答案（C# 语言范畴之内），如果有不准确、不全面的，欢迎各位朋友指正！ 1.静态变量和非静态变量的区别？ 答：静态变量： 静态变量使用 static 修饰符进行声明 在所属类被装载时创建 通过类进行访问
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个月。
或许还有不少人对于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;
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)。