cpp学习记录
每天进步一点点。
强制类型转换
static_cast
int main() {
double oneDouble = 6.66;
int oneInt = static_cast<int>(oneDouble);
cout << oneInt << endl; // 6
}
实际上，可以省略static_cast、有时候可以自动类型转换
const_cast
使用const_cast可以将常量指针转化成非常量指针，从而可以改变量值
int main() {
int a = 10;
const int *q = &a;
int *p = const_cast<int *>(q);
*p = 666;
// *q = 444; // error: assignment of read-only location '* q'
cout << *p << endl; // 666
cout << a << endl; // 666
}
函数参数默认值
形参默认值可以是没有名字的
void func(int a = 1,int =2){
cout<<'haha'<<endl;
}
形参默认值必须遵循从右往左
void func(int a, int b = 2, int c = 3) {
cout << 'haha' << endl;
}
形参默认值可以是表达式
void func(int a, int b = 2, int c = max(1,2)) {
cout << 'haha' << endl;
}
（但不允许是函数内定义的局部变量）
引用和函数参数的传递
特征
引用就是变量的别名
引用不会新建内存空间，只能指向已经初始化的变量，int型变量在C++98默认初始化为0
引用的命名规则同函数名一样
引用不能使用引用进行初始化，（也不能用常量初始化引用）
同一个变量的引用可以有多个
对引用加上const表示常引用，不可使用常引用修改其所引用的变量的值
对引用进行初始化时：
// const int& 不能直接转int&
int &r = ref; // error
int &r = (int &)ref; // ok!
// const int 不能直接转int&
int &r = cint; // error
int &r =(int &)cint; //ok!
引用在函数中的使用
传递引用参数可以修改变量的值
void changeValue(int &a) {
a = 666;
}
int main() {
int oneInt = 0;
changeValue(oneInt);
cout << oneInt << endl; // 666
}
引用作为函数返回值
引用作为函数返回值可以当做左值来使用：
int &refValue(int &x) {
return x;
}
int main() {
int oneInt = 0;
refValue(oneInt) = 1;
cout << oneInt << endl; // 1
}
const与指针同用
这个昨天总结过了
补充：
int main(){
int a = 1;
// 以下两种写法等价
int const * const p1 = &a;
const int * const p2 = &a;
}
内联函数
内联函数用来解决每次调用函数保存现场和返回地址，在栈中为形参和局部变量分配存储空间，实现实参与形参的参数传递…。总之，调用函数时，会带来程序运行时间上的开销，使程序运行效率降低。
内联函数主要应用于代码量少的函数，编译程序会把整个内联函数复制到调用处，会增加程序的长度。
对于代码量较大的函数，或者函数中有循环语句或switch语句通常不定义为内联函数，因为对增加程序长度所带来的不利影响抵消了使用内联函数所带来的速度的改善。
inline void sayHello() {
cout << "Hello!" << endl;
}
int main() {
sayHello();
}
函数重载
实现函数的重载必须满足下列条件之一：
- 参数表中对应的参数类型不同
- 参数表中参数个数不同
参数表中对应的参数类型不同
定义三个重名但形参类型不同的函数：
int bigger(int a, int b) {
return max(a, b);
}
float bigger(float a, float b) {
return max(a, b);
}
double bigger(double a, double b) {
return max(a, b);
}
int main() {
int aI = 1, bI = 2;
float aF = 1.1, bF = 2.1;
double aD = 1.1, bD = 2.1;
cout << bigger(aI, bI) << endl; // 2
cout << bigger(aF, bF) << endl; // 2.1
cout << bigger(aD, bD) << endl; // 2.1
}
参数表中参数个数不同
void show(const string &n1) {
cout << n1 << endl;
}
void show(const string &n1, const string &n2) {
cout << n1 << n2 << endl;
}
int main() {
show("孙泽辉"); // 孙泽辉
show("孙泽辉","好菜啊"); // 孙泽辉好菜啊
}
函数重载类型提升
double bigger(double a, double b) {
return max(a, b);
}
int main() {
int aI = 1, bI = 2;
cout << bigger(aI, bI); // 2
}
代码里没有给出原型是bigger(int,int)的函数，int可以自动转换为double，经过类型转换后找到了调用的函数。
调用重载函数的二义性
上面提到的int可以自动转换为double，假如我传入bigger(int,float)或bigger(int,double)，这时候编译器就分不清该去执行哪个函数，会报错。
另外，在两个函数同名而参数不同时，其中参数多的那个函数可以取到默认值的情况下，也会发生二义性。如：
double bigger(double a, double b, double c = 3.3) {
return max(a, b, c);
}
double bigger(double a, double b) {
return max(a, b);
}
int main() {
int aI = 1, bI = 2;
cout << bigger(aI, bI);
cout << bigger(aI, bI, 9.9);
}
// error:call of overloaded 'bigger(int&, int&)' is ambiguous
// ambiguous
//英 [æmˈbɪɡjuəs] 美 [æmˈbɪɡjuəs]
//adj.模棱两可的;含混不清的;不明确的