title: c++基础(const关键词, 命名空间, 引用, 内联函数)
date: 2018-09-11 18:09:01
tags:
- const
- namespace
- reference
- inline
categories: cpp
blog: http://withas.me
正好这学期在学c++, 打算把自己学习的都记录一下.
这篇文章主要是c++中的一些不同于c的特性.
const关键词
const通常用来表示常量,主要有以下一些用法:
符号常量
const type V = value表示V是一个常量.
在c语言中常量可以用宏定义, 如#define PI 3.14. 这种方式在编译时把代码中的PI全都替换为3.14, 就是说PI这个常量是没有被保存在内存中的. 而用cosnt定义的变量会保存在内存的常量区.
修饰函数形参
用cosnt修饰的形参在函数指向过程中不能被修改.
int func(const int a) {
// a++;//error
return a + 5;
}
当一个函数的功能明确不能或者不需要修改参数时可以用cosnt修饰该参数.
修饰指针变量
const修饰指针变量有以下三种情况:
指向常量的指针
指向常量的指针, 也可以指向变量, 但是指针认为它指向了常量, 所以不能通过指针修改.
cosnt int a = 10;
int b = 11;
const int *p_a = &a;//a是常量
const int *p_b = &b;//ok, 指向常量的指针也能指向变量
// *p_a = 5;//error
// *p_b = 6;//error虽然指向变量, 但是不能通过指针修改
常指针
指针变量是个常量, 必须初始化. 不能指向常量(常量只能被指向常量的指针指向), 可以通过指针修改. 其实就相当于一个普通指针, 但是赋初值后不能修改指向的地址.
// int *const p = &a;//error
// 不能指向常量
int *const p = &b;
*p = 20;//ok
// p = &a;//error
// 不能被修改
类中的this指针就是个常指针, 只能指向当前对象.
指向常量的常指针
只能指向常量, 而且本身是个常量, 是前两者的结合体.
// c 指向常量的常指针 什么都不能改
const int *const p_c = &a;
命名空间(namespace)
namespace可以用来区别不同文件里的相同名称的函数, 变量等.
namespace first_space {
int a = 10;
int func(const int a);
// 嵌套namespace
namespace second_space {
int b = 11;
}
}
//不连续命名空间
namespace first_space {
// int a = 10;//error
int b = 12;
}
//对命名空间中函数的实现
int first_space::func(const int a) {
return a + 10;
}
要使用命名空间中的成员, 需要使用::运算符, 如first_space::a.
可以用using namespace space_name;来表示使用的命名空间, 这样可以省略命名空间, 比如要使用c++的标准库, 一般会using namespace std;.
引用(reference)
引用相当于给变量取个别名.
int e = 10;
int &f = e;
cout << e << endl;
f = 11;
cout << e << endl;
这里f相当于是e的一个别名, 修改两者中的任何一个, 另一个会跟着一起改变.
按引用传参
c++的默认传参方式是按值传参, 实参的值会被复制到形参中.
而按引用传参不会复制, 而是直接引用实参, 不过会给实参取一个别名.
void add_five(int &a) {
a += 5;
}
其实大多数编程语言都是默认都是按值调用(call by value), 比如对于java来说只有call by value, 而c++有两种参数传递方式: 按值调用(call by value), 按引用调用(call by reference).
指针传递
c++传递指针作为参数, 还是call by value
void func(int *p) {
*p = 10;//通过指针可以修改指向的值
p = NULL;//但是调用处的指针变量不会因为p变成NULL也变成NULL
//因为调用处把传递的指针的值复制一份给了p, 修改p不会改变原来指针的值
}
java call by reference?
java中的对象变量储存的是对象的应用, 那么把对象变量作为参数传递是call by reference吗? 事实上, 这还是call by value, 不过传递的是引用的备份, 类似于c/c++中传递指针.
public static void swap(Object a, Object b) {//doesn't work
Object temp = a;
a = b;
b = a;
}
//call
swap(a, b);
调用swap函数处a, b的值并没有变化, 因为函数中只是a, b引用的备份, 并非调用处a, b. 而正真的call by reference 是可以改变调用处实参的值.
void swap(int &a, int &b) {
int temp = a;
a = b;
b = a;
}
//call
int a = 4, b = 5;
swap(a, b);
//a = 5, b =4
好像很多人都没有搞清楚call by reference, 事实上call by reference只存在少数编程语言中. 虽然有时它的应用会简化程序, 不过个人认为call by value更加符合程序设计原则(不负责任偏激的见解).
修饰函数返回值
这是个有点变态的操作, 暂时没有搞懂有什么神奇操作
int &fn(int &b) {
return b;
}
//main
int n = 9;
fn(n) = 11;
//此时n=11
是不是很变态, 我第一看到也一脸懵逼.
内联函数(inline)
内联函数, 这是一个很实用的特性. 内联函数并不会真的被调用, 简单来说就是把函数的语句直接复制到执行的地方执行, 但是又不是像宏无脑的替换. 对于一些经常调用的函数, 这样可以减少函数调用的开销.
inline int max(int a, int b) {
return a > b ? a : b;
}
//main
int a = 10, b = 20;
int c = max(++a, --b);
//c = 19
调用max的地方语句会被这样替换:
++a;
--b;
int c = a > b ? a : b;
对比以下宏定义的方式:
#define max(a, b) ((a) > (b) ? (a) : (b))
//main
int a = 10, b = 20;
int c = max(++a, --b);
//c = 18
//此处语句被替换为
int c = (++a) > (--b) ? (++a) : (--b);
//所以最后结果为18