关于for循环
for (init-statement ; condition ; expression)
{
statement
}
其中的init-statement会在循环开始之执行前被执行一次。
condition用于循环控制，其值会在每次循环迭代之前被计算出来，如果condition==true，statement会被执行。
expression会在循环每次迭代结束后被求值。
因此，以下两个例子的输出结果是一样的。
for(int ix=3;ix<5;ix++)
{
cout<<ix<<endl;
}
cout<<" "<<endl;
for(int ix=3;ix<5;++ix)
{
cout<<ix<<endl;
}
存在的说法是
如果 i 是系统类型，两者没有性能区别。绝大多数编译器可以生成同效率代码。由于所谓的多余复制的变量并没有被用到（i++的返回值
无人使用），所以编译器优化之后跟++i等价。两者性能区别理论上存在于当 i 是一个自定义的类，并且这个类重载了++操作符，并且
这个类重载「后增量」操作符时使用了值复制作为返回值的情况，在这种情况下，有时编译器能优化掉多余的复制，有时不能。所以++
对于自定义对象类型来说会有题主所说的情况。
关于内置类型对象的初始化（P49）
内置类型的对象，如果定义在file scope之内，必定被初始化为0。但如果它们被定义于local scope之内。那么除非程序员指定其初值，否则不会被初始化。
存在的说法是
把没有特别指定初始值的全局空间初始化为0不需要程序本身付出任何直接成本。程序不需要额外的数据记录这些0，也不需要额外的
代码去设置这些0，这活操作系统直接就能替你干了。而初始化成0，实际上就是抹去内存中原来的数据，这很政治正确。对于局部变
量，初始化必须通过函数内代码实现，不论空间还是时间都有成本，而且是每次调用都有的时间成本。而栈中的数据本来也都是应用
自己的数据，不存在抹不抹的问题。
关于把输出信息打印到指定文件
ofstream ofil("相对路径\\text_out1");
void func(int size)
{
for(int i = size;i>=0;--i)
{
ofil << i<<" ";
}
ofil << endl;
}
int main()
{
func(10);
}
接下来就可以在text_out1文件中看到打印出来的信息，而不是在终端
Practical Example：
如果我想在某个文件中打印消息，并且把“在终端打印”or“在一个指定的文件打印”作为可选项（即函数参数）来增加函数复用性
原打印函数：
void display(const vector<int> &vec)
{
for ( int ix=0; ix < vec.size(); ++ix)
{
cout << vec[ix] << ' ';
}
cout << endl;
}
测试一下：
int main()
{
int ia[8] = {8,34,3,13,1,21,5,2};
vector<int> vec(ia,ia+8);
display(vec);
}
可选打印方式的打印函数：
void display(const vector<int> &vec, ostream &os = cout)
{
for (int ix=0;ix<vec.size();++ix)
{
os << vec[ix] <<' ';
}
os << endl;
}
int main()
{
int ia[8] = {8,34,3,13,1,21,5,2};
vector<int> vec(ia,ia+8);
// 默认终端打印
display(vec);
// 在指定文件内打印
ofstream ofil("路径");
display(vec,ofil);
}
关于C++中默认参数值的提供：
规则1：
默认值的解析（resolve）操作由最右边开始进行。如果我为某个参数提供了默认值，那么这个参数右边的所有参数都必须具有默认的参数值。例如下面的例子是非法的：
void display(ostream &os = cout ,const vector<int> &vec){}
规则2：
默认值只能够指定一次，可以在函数声明处，也可以在函数定义处，但不可两个地方都指定。一般为了更高的可见性，会将默认值放在函数的声明处而非定义处。如下：
NumericSeq.h（头文件）：
void display(const vector<int> &vec, ostream &os = cout);
函数定义处；
#include "NumericSeq.h"
void display(const vector<int> &vec, ostream &os)
{
for (int ix=0;ix<vec.size();++ix)
{
os << vec[ix] <<' ';
}
os << endl;
}
\n 和 endl 的区别
std::cout << std::endl;
相当于
std::cout << '\n' << std::flush;
或者
std::cout << '\n'; std::fflush(stdout);
由于流操作符 << 的重载，对于 ‘\n’ 和 “\n”，输出效果相同。
对于有输出缓冲的流（例如cout、clog），如果不手动进行缓冲区刷新操作，将在缓冲区满后自动刷新输出。不过对于 cout 来说（相对于文件输出流等），缓冲一般体现得并不明显。但是必要情况下使用 endl 代替 ‘\n’ 一般是个好习惯。
对于无缓冲的流（例如标准错误输出流cerr），刷新是不必要的，可以直接使用 ‘\n’。
关于以下代码的一个疑问（P54）
const vector<int>* fibon_seq(int size)
{
~~~
return 0;
~~~
}
为什么return一个0，函数定义的返回值不应该是一个空指针吗？
来自孔师兄的解答——“你看的书太老了（Essential C++），C++11之后，用的都是nullptr，也就说人家返回的确实是一个地址”
我自己的验证：
#include<typeinfo>
const int * add(int num1,int num2)
{
// 用来验证return 0 和return nullptr是不是和&c一样，确实返回了地址
static int c=0;
if(num1==0)
return &c;
// 用来验证0和nullptr的作用是不是一样的
else if(num1 == 1)
return nullptr;
else if(num1 == 2)
return 0;
}
int main()
{
const int *c1 = add(0,1);
cout<<"c1="<<c1<<endl;
cout<<"*c1="<<*c1<<endl;// 由于有实际的值，因此解引用不报错
cout<<typeid(c1).name()<<"\n";
const int *c2 = add(1,1);
cout<<"c2="<<c2<<endl;
// cout<<"*c2="<<*c2<<endl; 解引用空指针，报错
cout<<typeid(c2).name()<<"\n";
const int *c3 = add(2,1);
cout<<"c3="<<c3<<endl;
// cout<<"*c3="<<*c3<<endl; 解引用空指针，报错
cout<<typeid(c3).name()<<"\n";
cout<<"-------------\n";
// 再次验证空指针的打印值0，但解引用出错
int * x = nullptr;
cout<<x<<endl;
cout<<*x<<endl;
}
关于为什么空指针打印出来不是地址而是0？
空指针：就是一个被赋值为0的指针，它不指向任何的对象或者函数。
在C++11后，不再使用0，而是nullptr指针，这是一个定义在标准库中的值为零的常量
使用指针的第一件事就是需要看这个指针是否是空指针（坚决不能使用空指针，否则程序就会蹦。意思就是：为一个指针赋值为空指针是不会报错的;但是在使用的时候一定要判断是否为空指针（即该指针有没有指向），不为空才能操作）
- 因此，在上例中，返回的确实是一个地址，只不过其值是0，而对空地址解引用是违规操作。
参数——个数不同用重载，类型不同用模板
一般来讲：
-
如果函数具备多种实现方式，我们可以将其重载（overload），其每份实例提供的是相同的通用服务。
-
如果我们希望让程序代码的主体不变，仅仅改变其中用到的数据类型，可以通过function template达到目的。
重载Example：
void display_message(const string x)
{
cout<<"first"<<endl;
}
void display_message(const string x,int y)
{
cout<<"second"<<endl;
}
void display_message(const string x,int y,int z)
{
cout<<"third"<<endl;
}
int main()
{
display_message(1);
display_message("hang",1);
display_message("hang",1,1);
}
模板Example1：
template<typename elemType>
void display_message(const string x,elemType y)
{
cout<<x<<" "<<y<<endl;
}
int main()
{
display_message("hang",1);
cout<<endl;
display_message("hang","wang");
}
模板Example2：
template<typename elemType>
void display_message(const string &x,vector<elemType> &vec)
{
cout<<x<<" ";
for(int ix=0;ix<vec.size();++ix)
{
elemType t = vec[ix];
cout<<t<<" ";
}
cout << endl;
}
int main()
{
const int size = 5;
int t1[size] = {1,2,3,4,5};
char t2[size] = {'a','b','c','d','e'};
vector<int> t3(t1,t1+size);
vector<char> t4(t2,t2+size);
display_message("hang",t3);
display_message("hang",t4);
}
关于多级指针
int main()
{
int x = 1;
int *p1 = &x;
int **p2 = &p1;//可以看作int *(*p2) = &p1;，但编译器会提示warning:unnecessary parentheses
int ***p3 = &p2;
cout <<p1<<endl;
cout <<*p1<<endl;
cout<<p2<<endl;
cout<<*p2<<endl;
cout << p3<<endl;
cout <<*p3<<endl;
}
输出：
0x61fe14
1
0x61fe08
0x61fe14
0x61fe00
0x61fe08
函数指针
函数指针（pointer to function）是指针，它必须指明其所指函数的返回类型及参数列表；此外，函数指针的定义必须将*放在某个位置，表示这份定义所表现的是一个指针。
eg：
const vector<int>* *seq_str(int)
//这将seq_str定义为一个函数，参数列表中只有一个int类型，返回类型是个指针，这个指针指向另一个指针，后者指向一个const vector，其元素类型为int！为了让seq_str是一个指针，必须以小括号改变优先级，如下：
const vector<int>* (*seq_str)(int)
定义与声明
函数的定义只能有一份，但可以有很多份声明。因此不把函数的定义放在头文件中。
但有一个例外，inline函数。为了扩展inline函数的内容，在每个调用点上，编译器都能取得其定义。这意味着必须将inline函数的定义放在头文件中，而不是把它放在各个不同的程序代码文件中。
类似的，在file scope中定义的对象，如果可能被多个文件访问，就应该被声明于头文件中，而不是放在各个不同的程序代码文件中。
假如想把下面的函数指针在头文件中声明，如下
const int seq_cnt = 6;
const vector<int>* (*seq_array[seq_cnt])(int);
是错误的，因为这会被解读为seq_cnt的定义而非声明，正确格式如下
extern const vector<int>* (*seq_array[seq_cnt])(int);
extern的作用：extern可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。
可能你会疑惑，既然如此，seq_cnt对象为什么不需要加extern关键字呢？
这是因为const object和inline函数一样，是例外。const object的定义只要一出文件外便不可见，which means we can 在多个程序文件中加以定义。而seq_array是一个指向const object的指针，本身并不是const object，因此需要加extern。
扫一扫
318
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
