编译期常量折叠

Ⅰ C++中常量赋值是如何规定的

1、值替代
C语言中预处理器用值代替名字：

#define BUFSIZE 100

这种方式在C++中依然适用，同时

C++用const把值代替带进编译器领域：
const bufsize = 100 ;或 const int bufsize = 100 ;
同时还可以执行常量折叠：
char buf[bufsize] ;
1.1 头文件里的const
与使用#define一样，使用const必须把const定义放在头文件里。这样，通过包含头文件，可把const定义单独放在一个地方，并把她分配给一个编译单元。const默认为内部连接，即仅在const被定义过的文件里才是可见的，而在连接时不能被其他编译单元看到。
比如说在Test.h中定义了,

const int nTestConst = 1000;

在A.cpp中include"Test.h"
同时在B.cpp中include"Test.h"
不会出现,当没有定义为const时,因变量定义出现两次而出错的情形.
当定义一个const常量时，必须赋一个值给它，除非用extern作了清楚的说明：

extern const bufsize ;

虽然上面的extern强制进行了存储空间分配，但C++编译器并不为const分配存储空间，相反它把这个定义保存在它的符号表里。当const被使用时，它在编译时会进行常量折叠。

1.2 const的安全性
如果想要一个值保持不变，就应该使它成为一个常量(const)。
1.3 集合
const可以用于集合，但必须分配内存，意味着“不能改变的一块存储”。但其值在编译时不能被使用。


const int i [] = {1,2,3,4};
// float f [ i [3] ]; // Illegal

2,指针
当使用带有指针的const时，有两种选择：1、或者const修饰指针正指向的对象，2、const修饰存储在指针本身的地址。
2.1 指向const的指针
使用指针定义的技巧，正如任何复杂的定义一样，是在标识符的开始处读它并从里到外读。如果我们要使正指向的元素不发生改变，得写：

const int * x;

从标识符开始：“x 是一个指针，指向一个const int。”
把const从一边移到另一边，结果一样。
int const * x;
2.2 cosnt指针
是指针本身成为一个const指针，必须把const标明的部分放在*的右边，如：

int d = 1;
int * const x = &d;

指针本身是const指针，编译器要求给它一个初始化值，这个值在指针寿命期间不变。然而要改变它所指向的值是可以的，可以写*x = 2。
这些可以总结成这样一句话:
以*为分界点,
当const在*的左边时,实际物体值不变
当const在*的右边时,指针不变,
即,左物右指
这样来记比较方便!!

Ⅱ java中编译期常量所指的是什么

classInitalizedClass{
	static{
		System.out.println("!");
	}
	publicstaticintinititalize_varible=1;

}

{
	publicstaticvoidmain(String[]args){
		System.out.println(InitalizedClass.inititalize_varible);

	}

}

上面的结果是：
!
1

classInitalizedClass{
	static{
		System.out.println("!");
	}
//和上面的例子唯一的差异就是此处的变量INITIALIZED_VARIBLE被声明为final
	_VARIBLE=1;

}

{
	publicstaticvoidmain(String[]args){
		System.out.println(InitalizedClass.INITIALIZED_VARIBLE);

	}

}

上面的结果是：
1

为什么两个例子执行结果不一样，原因是第二个例子中的INITIALIZED_VARIBLE为编译期常量，它不会导致类的初始化的

Ⅲ String a="a"; String b="b"; a=a+b; 这里共创建了几个对象

这里共创建了3个对象。

"a"+"b"+"c"在编译期已经常量折叠为"abc"，变量a获得是"abc"。

甲骨文jdk（1.7），javac会进行常量折叠，全字面量字符串相加是可以折叠为一个字面常量，而且是进入常量池的。这个问题涉及到了字符串常量池和字符串拼接。

只创建了一个对象，在字符串池只会有一个对象。因为它是一行定义的对象，编译时只会初始化一次字符串缓冲池的数据。如果是 String a="a";String b="b";String c="c";String d=a+b+c；这里就创建了4个对象。

(3)编译期常量折叠扩展阅读

String 对象的实现：

String 对象的创建方式

1、通过字符串常量的方式

String str= "pingtouge"的形式，使用这种形式创建字符串时， JVM 会在字符串常量池中先检查是否存在该对象，如果存在，返回该对象的引用地址，如果不存在，则在字符串常量池中创建该字符串对象并且返回引用。

使用这种方式创建的好处是：避免了相同值的字符串重复创建，节约了内存

2、String()构造函数的方式

String str = new String("pingtouge")的形式，使用这种方式创建字符串对象过程就比较复杂，分成两个阶段，首先在编译时，字符串pingtouge会被加入到常量结构中，类加载时候就会在常量池中创建该字符串。

然后就是在调用new()时，JVM 将会调用String的构造函数，同时引用常量池中的pingtouge字符串，在堆内存中创建一个String对象并且返回堆中的引用地址。

Ⅳ 在学习到const_cast时引发的疑惑，寻求协助，谢谢~

//问题一：不会，a仍然是常量，任何转换都不能将被转换对象转换成别的形式，而只能是使用转换后的结果。
//问题二：对于C++，简单类型的常量会视情况给予分配内存空间或不分配而直接按符号常量来处理，当被定义的常量后面有取该常量地址的操作时（即使用&运算符），它会被分配内存空间而等同与C语言中的常量，当没有对其进行取地址运算时，它就等同于#define定义的宏，即符号常量。第6行中的arr也存在相同的情形，即可能被分配空间也可能被当成符号常量，比如arr[2]可能被实现成*(arr+2)也可能直接将arr[2]当成一个符号常量，这要看编译器是否进行了深度优化。
//问题三：定义在全局数据区中的标识符，其中的static只有一个作用：即禁止使用extern关键字声明它以在别的文件中使用该标识符，基于此，value与普通常量没什么差别，只是无法在别的文件中使用value而已。
//问题四：在我的VC6编译器中，即使移除static也会出现内存非法操作错误，这个问题是C++标准中未明确规定所导致的，C++并没有规定常量必须放到哪种类型的内存中，但编译器经常会将常量放到只读内存中，而只读内存是不允许写操作的，因此第四行会出现内存非法操作的运行时错误。
//问题五：value何时被重新分配内存了？对value取地址取的就是定义value时的地址。
//问题六：在你的这段代码中，很明显value被编译器实现成了符号常量，因此*pa=10修改的是另一个“克隆”内存区，而你输出value时等价于直接输出5，而常量数组arr则被实现成非符号常量即真正的有内存地址的常量，因此可以修改其中的值。

Ⅳ define定义的符号常量和用const定义的变量有什么不同为什么不用const修饰常量呢

define 预编译期的。
const 是编译期的。

define 定义值一个符号 没有类型之分的
const 编译指定了类型。

为什么不用const修饰常量呢 。 const 修饰的表示一个常量。内部类型会常量折叠的，不会分配地址空间

Ⅵ C++语法高手进

C 基本语法(上)
0. 编译C 程序时，编译器自动定义了一个预处理名字__cplusplus，而编译标准C时，自动定义名字__STDC__。另外几个比较有用的预定义名字是__LINE__(文件的当前编译行数)，__FILE__(当前被编译的文件名字)，__DATE__(编译日期)和__TIME__(编译时间)。

1. C库头文件的C 名字总是以字母C开头，后面去掉后缀.h的C名字，如在C 库中的名字是。两种使用方法：
#include 或者
#include
using namespace std;

2. 静态与动态内存分配的两个主要区别：(1)静态对象是有名字的变量，可以直接进行操作，动态对象是没有名字的变量，可以通过指针间接进行操作；(2)静态对象的分配和释放由编译器自动处理，而动态对象必须由程序员显式的管理，通过new和delete两个表达式来完成。

3. 类的缺省构造函数是不需要用户提供任何参数的构造函数。

4. STL中标准数组-vector(文件)，两种遍历方式：(1)通过下标操作符；(2)使用迭代器，如vector<int>::iterator iter;可以通过对iterator解引用来直接访问实际的元素*iter;STL提供了作用于容器类型的泛型算法，头文件。

5. 文字常量是不可寻址的。

6. 常用的几个转义序列：
newline(换行符) \n \14
horizontal tab(水平制表符) \t
vertical tab(垂直制表符) \v
backspace(退格符) \b
carriage return(回车键) \r
formfeed(进纸键) \f
alert (bell)(响铃符) \a \7

7. 变量和文字常量都有存储区，区别在于变量是可寻址的，对于每个变量，都有两个值与之关联：数据值，称为对象的右值，是被读取的值，文字常量和变量都可以用作右值；地址值，被称为变量的左值，是位置值，文字变量不用被用作左值。

8. 每个指针都有一个相关的类型。不同数据类型的指针之间的区别在于指针所指的对象的类型上。如果我们需要的仅仅是持有地址值，C 提供了一种特殊的指针类型：空(void *)类型指针，它可以被任何数据指针类型的地址值赋值，除了函数指针。不能操作空类型指针所指向的对象，只能传送该地址值或将它与其他地址值做比较。

9. C风格的算法循环：
while(*p ){…}

10. 正确定义引用，如下：
const int ival = 1024;
const int *&pi_ref = &ival; // 错误，pi_ref是一个引用，它指向定义为const的int型对象的一个指针，引用不是指向常量，而是指向了一个非常量指针
const int *const &pi_ref = &ival; // OK

11. 指针和引用有两个主要区别，引用必须总是指向一个变量；如果一个引用给另外一个引用赋值，那么改变的是被引用对象而不是引用本身。

12. 布尔类型对象虽然也被看作整数类型的对象，但是它不能被声明为signed，unsigned，short或long。

13. 一个数组不能被另外一个数组初始化，也不能被赋值给另外一个数组，而且，C 不容许声明一个引用数组。

14. 数组标志符代表数组中的第一个元素的地址。它的类型是数组元素类型的指针。
int ia[10];
第一个元素的地址: ia或者是&ia[0]
第二个元素的地址: ia 1或者是&ia[1]

15. STL中vector有两种不同的使用形式：数组习惯，即使用下标操作符，注意只能操作已经存在的成员；STL习惯，使用iterator来操作，对其解引用可以访问实际的对象，也可以通过加减来移动位置。雷同与5。

16. typedef用来为内置的或用户定义的数据类型引入助记符号。
typedef char *cstring;
extern const cstring cstr;
其中cstr的类型是 char *const cstr;

17. 当一个对象的值可能会在编译器的控制或监制之外被改变时，那么该变量应该声明为volatile，编译器执行的某些例行优化不能应用在已经指定为volatile的对象上。

18. pair类可以在单个对象内部把相同类型或不同类型的两个值关联起来。我们可以使用成员访问符号来访问pair中的单个元素，他们的名字为first和second。

19. 在类体外定义的内联成员函数，应该被包含在含有该类定义的头文件中。

20. setw()是一个预定义的iostream操作符，它读入的字符数最多为传递给它的参数减一。如setw(1024)，则最多读入1023个字符。

21. 标准C 头文件提供了与内置类型表示有关的信息，另外，还有标准C头文件和。

22. 对于二元操作符<或者>，左右操作数的计算顺序在标准C和C 中是都是未定义的，因此计算过程必须是与顺序无关的。如ia[index ]就是未定义的。

23. 初始化过程为对象提供初值，而赋值是用一个新值覆盖对象的当前值，一个对象只能被初始化一次，也就是在它被定义的时候，而赋值可以多次。如初始化int ival = 1024;赋值 ival = 1025;赋值操作符的左操作数必须是左值。

24. sizeof操作符的作用是返回一个对象或者类型名的字节长度，返回值类型是size_t，这是一种与机器有关的typedef定义，可以在文件中找到它的定义。

25. 按位非操作符(~)翻转操作数的每一位。移位操作符(<<和>>)将其左边操作数的位向左或者向右移动某些位，移到外面的位被丢弃，左移操作符从右边开始用0填充空位。右移操作符，如果是无符号数从左边开始插入0，否则它或者插入符号位的拷贝或者插入0，这由具体实现定义。按位与(&)对两个操作数的每一位进行与操作(只有两位同时为1时值才为1)。按位异或(^)操作符对两个操作数的每一位进行异或操作(只有两个含有一个1时值才为1，即两位不同值为1)。按位或(|)操作符对两个操作数的每一为进行或操作(只有两位同时为0时值才为0)。如将整数a的第27位设为1：a |= 1 << 27；将第27为设为0：a &= ~(1 << 27) ；测试第27位是否为1：a & (1 << 27)。

26. bitset类，头文件为，支持三种构造方式，第一是直接指定向量长度，如bitset <32> bs;第二是显式提供一个无符号参数，如bitset<32> bs(012);将第1和第3位设置为1。第三是传递一个代表1和0集合的字符串参数，还可以标记字符串的范围，如string bitval(“1111110101100011010101”);bitset<32> bs(bitval, 6, 4);则bs的第1和第5位被初始化为1；如果去掉指定字符串范围的第三个参数，则范围是指定的位置开始一直到字符串的末尾。而函数to_string和to_ulong则把bitset对象转换为字符串和整型表示。

27. 操作符优先级表

28. 隐式转换发生在下列情况下：1.混合类型的算术表达式，即算术转换；2.用一种类型的表达式赋值给另一种类型的对象；3.把一个表达式传递给一个函数调用，表达式的类型和形式参数的类型不相同；4.从一个函数返回一个表达式。

29. 算术转换的两个原则：1.如果必要的话，类型总是提升为较宽的类型；2.所有含有小于整型的整值类型的算术表达式，在计算之前，其类型都会被转换为整型。

30. const_cast转换掉表达式的常量性以及volatile对象的volatile性；如const_cast<char *>ptr；编译器隐式执行的任何类型转换都可以由static_cast显式完成。reinterpret_cast通常对操作数的位模式执行一个比较低层次的重新解释。dynamic_cast支持在运行时刻识别由指针或引用指向的类对象。

31. typename是标准C 中新引入的关键字，用于template中。

32. 两个主要的顺序容器是list和vector，另外一个顺序容器是deque；两个主要的关联容器是map和set。

33. 选择顺序容器类型的一些准则：(1)随机访问，vector比list好得多；(2)已知道元素的个数，则vector比list强；(3)如果不只是在容器两端插入和删除元素，则list比vector强很多；(4)除非需要在容器首部插入和删除元素，则vector比deque好。对于小的数据类型，vector的插入大批量数据的性能比list好很多，而大型数据时则相反，解决方案是只保留大型数据的指针。Reserve函数容许将容器的容量设置成一个显式指定的值，resize函数重新设置容器的长度；每个容器支持一组关系操作符；用户定义的类类型必须支持等于操作符，必须支持小于操作符，元素类型必须支持一个缺省值（对类类型，指缺省构造函数）。

34. 除了iterator类型，每个容器还定义了一个const_iterator类型，对遍历const容器是必需的，const_iterator容许以只读方式访问容器的底层元素。Iterator算术运算(是指加法或者减法等算术运算，而不是重载的 操作符)只适用vector或deque，而不适用于list因为list在内存中不是连续存储的。

35. string类的find函数返回一个索引类型string::size_type或者返回string::npos；find_first_of提供了被搜索字符串中任意一个字符相匹配的第一次出现，并返回它的索引位置，substr函数生成现有string对象的子串的一个拷贝，第一个参数指明开始的位置，第二个可选的参数指明子串的长度。rfind，查找最后的指定子串的出现；find_first_not_of查找第一个不与要搜索字符串的任意字符相匹配的字符；find_last_of查找与搜索字符串任意元素相匹配的最后一个字符；find_last_not_of查找字符串中的与搜索字符串任意字符全不匹配的最后一个字符。

36. tolower函数接受一个大写字符，并返回与之等价的小写字母，必须包含头文件，另外一些该文件中的函数，isalpha, isdigit, ispunct, isspace, toupper等。

37. assign对把字符串进行赋值；append则类似于 =操作符；swap交换两个string的值；进行越界检查的at类似于[]操作符；compare函数提供了两个字符串的字典序比较；replace函数提供了十种方式，可以用一个或者多个字符替换字符串中的一个或多个现有的字符。

38. map定义了一个类型value_type，表示相关的键值对，用于insert函数。

39. 关联容器支持以下两个函数：find查找指定key，不存在则返回end()；count返回指定key值的出现的次数。

40. set定义了一个类型difference_type，是两个iterator相减的结果类型；inserter类用来执行插入操作。如:(in, eos, inserter(set1, set1.begin());因为执行的是赋值操作，所以使用inserter使用插入操作取代赋值操作。

41. multiset和multimap的特殊操作equal_range返回iterator对值，如:pair pos; pos = mp.equal_range(tst);

42. stack类，头文件，函数top和pop分别是访问栈顶元素和删除栈顶元素。栈类型是容器适配器，因为它把栈抽象施加到底层容器上，缺省情况下栈使用deque实现，可以自定义缺省的底层容器，如使用list构建stack：stack<int, list<int> > intStack;

43. C 中，数组永远不会按值传递，它总是传递第一个元素(准确的说是第0个)的指针。多维数组被传递为指向第0个元素的指针。如matrix[][10]等同于int (*matrix)[10]，都表示matrix是个二维数组，每行10列。而int *matrix[10]表示一个含有10指向int的指针的数组。

44. UNIX系统函数chmod改变文件的保护级别，它的函数声明在系统头文件中。

45. 链接指示符的第一种形式由关键字extern后跟一个字符串常量以及一个普通的函数声明构成，如extern “C” void exit();第二种形式是是多个函数声明用大括号包含再链接指示符复合语句中。链接指示符不能出现在函数中，而且放在头文件中更合适。

46. 支持命令行格式的主函数:int main(int argc, char *argv[]);

47. 指向函数的指针，如int (*pFunc)(int, int)；将取地址符作用于函数名上也能产生指向该类型的指针。如已经存在函数定义int f1(int); int (*pf1)(int)=f1; int (*pf2)(int)=&f1;函数调用可以使用pf1(1)格式或者(*pf1)(1)格式。当一个函数名没有被调用操作符修饰时，会被解释为该类型函数的指针，如存在函数定义int f(int)；表达式f被解释为int (*)(int)。

48. 函数指针数组的定义:int (*testCases[10])();使用typedef可以使声明更易读。如typedef int (*PFV)(); PFV testCases[10];声明一个“指向函数指针数组的指针”，如PFV (*pArray)[10];调用其中函数(*pArray)[2]();

49. 函数参数的类型不能是函数类型，函数类型的参数将被自动转换为该函数类型的指针。如存在函数类型typedef int funtype(int);void sort(int, funtype);与函数定义sort(int, int(*)(int));等价。函数指针也可以作为函数返回值的类型，如int (*ff(int))(int *, int);该声明将ff声明一个函数，它有一个int的参数，它的返回值为一个指向函数的指针，类型为int (*)(int *,int)；

50. 指向C函数的指针与指向C 的函数指针类型不同，也就是：int (*fcpp)(int)与extern “C” int (*fpc)(int)类型不同。并且，当链接指示符作用一个声明上时，所有被它声明的函数都受影响，如extern “C” void f1(void (*pfParm)(int));其中pfParm也是C函数指针。因此，要实现一个含有C函数指针作为参数的C 函数，可以使用typedef，如extern “C” typedef void FC(int); C 函数 void f2(FC *pfParam);

51. 关键字extern为声明但不定义提供了一种方法，extern声明不会引起内存被分配。

52. 设计头文件时不应该含有非inline函数和对象的定义。符号常量的定义和inline函数可以被重复定义多次，在编译期间，在可能的情况下，符号常量的值会取代该名字的出现，这个过程为常量折叠。符号常量是任何const类型的对象。但是如下定义不符合 char *const buf = new char[10];因为它的值不能在编译时确定，不能定义在头文件；const char *msg =”Error”;因为msg不是常量，它是指向常量值的非常量指针，必须修改为const char *const msg=””;

53. 有三种局部对象：自动对象，寄存器对象和局部静态对象。在函数中频繁使用的变量可以使用关键字register声明为寄存器对象。

54. delete表达式只能作用于由new表达式从空闲存储区分配的指针上，如果作用于其他内存指针上，可能导致问题，但是作用于值为0的指针上，delete不会指向任何操作。

55. auto_ptr是STL提供的类模板，可以帮助程序员自动管理用new表达式动态分配的单个对象。头文件为，只有拥有底层对象所有权的对象负责释放内存，但使用Copy constructor和Assignment进行操作时，左边的对象得到所有权，而右边的则被撤销所有权。使用get来测试是否指向一个底层对象，使用reset来重新设置一个底层对象，assignment操作符不支持内存指针。

56. 可以创建动态的const对象，如const int *pci = new const int(1024);不能创建const对象数组，创建的const对象必须初始化。

57. 定位new表达式容许程序员要求将对象创建在已经被分配好的内存中。如：char *buf=new char [1024];Foo *pb = new (buf) Foo;

58. 可以使用未命名的namespace来声明一个局部于某一文件的实体，即该函数只在当前文件中可见。通常在实现文件中使用，这种方法是用来替换C语言中的static函数声明。

59. 重载函数，两个函数的函数名相同，但函数参数表必须不同，参数个数或参数类型不同；识别函数声明并不考虑传值参数类型是const或者volatile，即void f(int)和函数void f(const int)是同一个函数。但是如果是传地址或者传引用时，则需要考虑这两个修饰符。void f(int *)和函数void f(const int *)为不同的函数。

60. 重载函数集合中的所有函数都应该在同一个域中声明。using声明和using指示符可以使得一个名字空间的成员在另外一个名字空间可见，这对重载函数集合产生影响。using声明总是为重载函数的所有函数声明别名，如果引入一个函数在该域中已经存在并且参数表相同，则产生错误。而extern “C”链接指示符只能指定重载函数集中的一个函数。

61. 函数重载解析的三个步骤(1)确定函数调用考虑的重载函数的集合，确定函数调用中实参表的属性；(2)从重载函数集合中选择函数，该函数可以在给定的情况下用实参进行调用；(3)选择与调用最匹配的函数。在第二步中，编译器确定需要进行的参数转换，并划分等级，通常分为精确匹配；与一个类型转换匹配；无匹配。其中类型转换通常分为三组：提升、标准转换和用户定义的转换。

62. 精确匹配细节：即使一个实参必须应用一些最小的类型转换才能将其转换为相应函数参数的类型；这些最小的类型转换包括：左值到右值的转换；从数组到指针；从函数到指针的转换和限定类型转换(通常是const和volatile类型转换)。精确匹配可以使用一个显式强制转换强行执行，这时实参类型就为转换后的类型。

C 基本语法(下)

0. 类型转换中的提示实际上就是内置数据类型的提升，如char转换为int，bool转换为int，float转换为double等。

1. 类型转换中的标准转换有五种类型：(1)整值类型转换(不包括提升)；(2)浮点转换；(3)浮点-整值转换；(4)指针转换和(5)bool转换。前三种转换是有潜在危险的转换。所有的标准转换都是等价的。一些注意点：0可以被转换为任何指针类型，这样创建的指针称为空指针值，同时0也可以是任何整型常量表达式。常量表达式0L及0x00都属于整值类型因此能够被转换为int *的空指针值。指针转换允许任何指针类型的实参转换成void *，但是函数指针不能用标准转换为void *。

2. 对于引用参数来说，如果实参是该引用的有效初始值，则为精确匹配，否则为不匹配。

3. 模板非类型参数代表了一个常量表达式，由一个普通的参数声明构成，表示该参数名代表了模板定义种的一个常量。在实例化时，该常量会被一个编译时已知的常量值代替。

4. 在模板中，为了支持类型表达式，必须使用typename；如typename Param::name *p;定义了一个指针p；如果不使用typename则该表达式为乘法。另外，模板函数也可以被声明为inline或extern，必须把指示符放在参数模板后。如template <typename T> inline T fun1(){…}

5. 函数实参的推演中三种类型转换是允许的：(1)左值转换；(2)限定转换(const和volatile指示符)；(3)到一个基类的转换：如果实参是一个类，它有一个从被指定为函数参数的类模板实例化而来的基类；如下面的代码：template <typename T> class Array {}; template <typename T> T min(Array &array) {…}；

6. 可以使用显式指定模板参数，模板参数被显式指定在逗号分隔的列表中，紧跟在函数模板实例的名字后面；如min<unsigned int>(a, b);代码强行指定模板参数以unsigned int转换。模板显式指定参数类似于默认参数，只能省略后面的参数。

7. C 支持两种模板编译模式：包含模式和分离模式。包含模式下，在每个模板被实例化的文件中包含函数模板的定义，并且往往把定义放在头文件中；分离模式下，函数模板的声明被放在头文件中，它的定义放在另外一个实现文件中，函数模板在实现文件中的定义必须使用关键字export。

8. C 支持模板的显式实例化，在显式实例化声明所在的文件中，函数模板的定义必须被给出。如template <typename T> T f(T t); 显式实例化为int *类型，template int *f(int *);

9. C 支持模板的显式特化定义，如：template <typename T> T max(T t1, T t2){…}显式特化const char *类型的定义：template <> const char *max<const char *>(const char *c1, const char *c2);显式特化隐藏了通用模板对于该类型的实例。如果模板实参可以从函数参数中推演出来，则模板实参的显式特化可以从其中取消。如上面的例子: template <> const char *max(const char *, const char *);其省略与显式指定模板参数一样。

10. 抛出异常可通过throw表达式来实现。如抛出一个popOnEmpty(类对象)的异常，表达式为throw popOnEmpty();同时在catch子句中，为了防止大型类对象的复制，可以将catch子句的异常声明改为引用。

11. 在查找用来处理被抛出异常的catch子句时，因为异常而退出复合语句和函数定义，这个过程称为栈展开。C 保证，随着栈的展开，尽管局部类对象的生命期是因为抛出异常而结束，但是所有的析构函数将被调用。要重新抛出接受到的异常，使用语句throw;重新抛出的过程中希望对接受到的异常对象进行修改，必须将catch子句的异常声明改为引用。

12. 异常规范跟随在函数参数表之后，用throw指定，后面是异常类型表。如void pop(int &value) throw(popOnEmpty);异常规范保证不会抛出任何没有出现在异常类型表中的异常。如果在运行时抛出一个没有出现在异常类型表中的异常，则系统调用C 标准库中定义的函数unexpected，该函数直接调用了terminate函数结束程序。空的异常规范不会抛出任何异常。

13. 异常规范可以在函数声明中指出，当有异常规范的指针被初始化时，被用作右值的指针异常规范必须比用作左值的指针规范一样或者更严格，当然，参数类型表必须相同。

14. 使用函数指针来使得template适应更多的场合。内置的函数指针声明的模板定义，代码如下: template< typename Type, bool (*Comp)(const Type&, const Type &)> const Type& min(const Type *p, Comp comp)；该方案的主要缺点是函数调用使它无法内联。使用函数对象来替代函数指针，函数对象是类实现，它重载了调用操作符，即operaotr ()函数。有两个优点：(1)如果被重载的调用操作符是inline，则编译器能执行内联编译；(2)函数对象可以拥有任意数目的额外数据来缓冲结果。改写模板使之能同时接受函数指针和函数对象(缺点是没有任何的原型检查)，template<typename Type, typename Comp> min(const Type *p, Comp comp);

Ⅶ java如何优化编译呢

#java编译器对`String常量表达式`的优化:
- 1.String+String 可以被编译器识别为常量表达
String a="ab" ;
String b="a"+"b";//编译后:b="ab"
System.out.println(a==b);//true
分析:
编译器将"a"+"b"当做常量表达式,在编译时期进行优化,直接取"ab". 在运行时期
并没有创建新的对象,而是从jvm字符串常量池中获取之前已经存在的"ab"对象.

- 2.String+基本类型 可以被编译器识别为常量表达式

String a="a1";
String b="a"+1; //"a1"
String c="a"+true;//"atrue"
String d="a"+3.14;//"a3.14"

#java编译器对`常量`优化:
* 它是编译时的一项优化技术,将代码的常量计算在编译期完成,节约了运行时的计算量.

1.常量替换
//编译前:
final int x=10;
int y=x;

//编译后
int x=10;
int y=10;//编译时,常量替换了

2.数学恒等式的模式匹配替换

//编译前:
int x=10+10;

//编译后
int x=20;//编译时,模式匹配替换了

3.常量折叠

//编译前:
boolean flag=true||(a || b && c);

//编译后
boolean flag=true;//编译时,常量折叠了

Ⅷ visual studio 如何在编译期确定字串长度，特殊宏之类的

宏的作用，只是在编译期间完成替代，并不能实现计算。因此不要考虑宏实现，这个没什么可行性。

编译期间数值确定，其实可以通过const关键字实现，但说实话，这个是“消耗空间换时间”，如果有log的函数太多，太分散，并不值得。

如果log比较集中的在几个函数中，那么可以这么做：

constintfnamelen=strlen(__FUNCTION_);
log(__FUNCTION_,fanmelen);

Ⅸ byte a=1;byte b=2;byte c=a+b;byte d=1+2; 请问第三句和第四句的计算机底层计算分别是怎么样的

分析：

d = 1 + 2; 1和2是常量，为固定不变的数据，在编译的时候（编译器javac），已经确定了1+2的结果并没有超过byte类型的取值范围，可以赋值给变量d，因此d=1+2 是正确的。

常量优化机制：

有一些计算，非常简单，例如常量和常量的计算就非常简单，在编译阶段就可以把这些简单的运算计算完。

反之， c = a + b ，a和b是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定 a + b 的结果是什么，因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。

Ⅹ java 中的编译期常量是什么使用它又什么风险

编译期常量就是所谓的 public final static 常量。
由于在编译时就确定了值，在使用的场合会直接写成值。而不是直接到原来的类中读取。
这样会有一个问题。 如果 类 A 提供了常量 类B使用了常量。并都进行了编译。
然后，修改了类A的源码，调用系统进行编译。
系统发现类A是新的代码，编译了，类B是旧的代码，就不进行编译，使用旧的类。
由于类B中直接编译进了旧的值，导致类A的修改无法反映到类B中。
这样造成了风险。