C++面向对象程序设计(三)——1.从C到C++
本文是中国大学MOOC，北京大学程序设计与算法（三）C++面向对象程序设计第一周笔记。
一 引用
引用的格式：类型名 & 引用名 = 某变量名
int & r = n; // r 引用了 n, r 的类型是 int &
- 1
某个变量的引用，其实相当于这个变量的另一个名字，二者是等价的
案例1.1
int n = 4;
int & r = n; // r 与 n 等价
r = 4;
cout << r; //输出 4
cout << n; // r 与 n 等价，因为 r = 4, 所以 n = r = 4
n = 5;
cout << r; // r 与 n 等价，因为 n = 5, 所以 r = n = 5
- 1
- 2
- 3
- 4
- 5
- 6
- 7
所以只要等价的其中一个变化了，另一个也要变化
值得注意的是：
- 定义引用时要将其初始化成引用某个变量。就跟初始化变量时尽量赋值是一个道理
- 初始化后，引用的就是这个变量，不会再引用别的变量了，从一而终
- 引用只引用变量，不能引用常量和表达式
案例1.2
double a = 4, b = 5;
double & r1 = a;
double & r2 = r1; //r2 , r1 , a 这三者是等价的
r2 = 10;
cout << a <<endl; //由于 r2 = 10, 所以 a = r1 = r2 =10
r1 = b;
cout << a <<endl; //由于 r1 = b, 所以 a = r2 = r1 = b = 5
- 1
- 2
- 3
- 4
- 5
- 6
- 7
案例1.3 交换函数
// C 语言
void swap( int * a, int * b)
{
int tmp;
tmp = * a;
* a = * b;
* b = tmp;
}
int n1, n2;
swap(& n1, & n2);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
// C++ 语言
void swap( int & a, int & b)
{
int tmp;
tmp = a;
a = b;
b = tmp;
}
int n1, n2;
swap(n1, n2);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
对比发现 C++ 的引用更为方便
案例1.4 作为函数的返回值
int n = 4;
int & SetValue(){ return n; }
int main()
{
SetValue() = 40;
cout << n;
return 0;
}//输出40
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
二 常引用
在引用前加const即为常引用
int n;
const int & r = n; // r 的类型是 const int &
- 1
- 2
值得注意的是：
- 不能通过常引用去修改引用的内容，要不然就不是常引用了
案例2.1
int n = 100;
const int & r = n;
r = 200; //编译错，n 可以改，r 不可以改
n = 300; //没问题
- 1
- 2
- 3
- 4
常引用与引用的转换
const T &和T &是不同的类型T &类型的引用或T类型的变量可以用来初始化const T &类型的引用const T类型的常变量和const T &类型的不能用来初始化T &类型的引用，除非使用强制转换
例题
1.下面程序片段哪个没错？
A. int n = 4; int & r =n * 5; //引用不可以出现 n * 5
B. int n = 6; const int & r = n; r = 7; //常引用不可以出现r = 7,不能通过常引用去修改引用的内容，要不然就不是常引用了
C. int n = 8; const int & r1 = n; int & r2 = r1 //常引用不可以出现int & r2 = r1,const T类型的常变量和const T &类型的不能用来初始化T &类型的引用，除非使用强制转换
D. int n = 8; int & r1 = n; const int r2 =r1;
2.下面程序片段输出结果是什么？
int a = 1,b = 2;
int & r = a; //r 与 a 等价
r = b;
r = 7;
cout << a <<endl; //输出 7
- 1
- 2
- 3
- 4
- 5
三 const关键字
#define类似于文档的全部替换，不会考虑上下文的意思。在C++中，推荐使用const
const int MAX_VAL = 23;
const string SCHOOL_NAME = “Peking University”
值得注意的是：
1.不可以通过常量指针修改其指向的内容
int n, m;
const int * p = & n;
* p = 5; //编译出错
n = 4; //ok
p = & m; //ok
- 1
- 2
- 3
- 4
- 5
2.不能把常量指针赋给非常量指针，反过来是可以的
const int * p1;
int * p2;
p1 = p2; //ok
p2 = p1; //error
p2 = (int * ) p1; //ok，强转
- 1
- 2
- 3
- 4
- 5
3.函数的参数为常量指针时，我们可以用来避免函数内部不小心改变参数指针所指地方的内容
void MyPrintf( const char * p)
{
strcpy(p,"this"); //编译出错
printf("%s",p); //ok
}
- 1
- 2
- 3
- 4
- 5
4.不能通过常引用修改其引用的变量
int n;
const int & r = n;
r = 5; //error
n = 4; //ok
- 1
- 2
- 3
- 4
例题
1.下面说法哪种是对的？
A.常引用所引用的变量，其值不能被修改
B.不能通过修改常量指针。去修改其指向的变量 //正确
C.常量指针一旦指向某个变量，就不能再指向其他变量
四 new实现动态内存分配
1.分配一个变量
P = new T; //T 是任意类型名，P 是类型为 T * 的指针
- 1
该语句动态分配处一片大小为sizeof(T)字节的内存空间，并将该空间的起始地址赋值给P
案例4.1
int * pn;
pn = new int;
* pn = 5;
- 1
- 2
- 3
2.分配一个数组
P = new T[N]; //T 为任意类型名；P 为类型为 T * 的指针；N 要分配到数组元素的个数，可以是整型表达式
- 1
该语句动态分配处一片大小为sizeof(T) * N字节的内存空间，并将该空间的起始地址赋值给P
案例4.2
int * pn;
int i = 5;
pn = new int[i * 20];
pn[0] = 20;
pn[100] = 30; //数组越界
- 1
- 2
- 3
- 4
- 5
五.用delete释放动态分配的内存
用了new动态分配一定要用delete释放
案例5.1
int * p = new int;
* p = 5;
delete p;
delete p; //异常，一个new只能delete一次
- 1
- 2
- 3
- 4
案例5.2
//delete动态分配的数组
int * p = new int[20];
p[0] = 1;
delete [] p;
- 1
- 2
- 3
- 4
例题
1.表达式 new int 的返回值类型是？
A int
B int * //正确
C int &
2.下面哪个正确？
A char * p = new int; p = ’ a ’ ; delete p ;
B int * p =new int [25]; p[10] = 100; delete p;
C char * p = new char[10]; p[0] = ‘K’; delete [] p; //正确
六 内联函数
inline int Max(int a, int b)
{
if( a > b) return a;
return b;
}
- 1
- 2
- 3
- 4
- 5
七 函数重载
一个或多个函数，名字相同，然而参数个数或参数类型不相同
例如：
int Max(double f1, double f2){} //Max(3.4, 2.5)
int Max(int n1, int n2){} //Max(2,4)
int Max(int n1, int n2,int n3){} //Max(1,2,3)
- 1
- 2
- 3
八 缺省函数
定义函数时，最右边的连续若干个参数有缺省值，那么在调用时候，如果那些位置不写参数，参数就是缺省值
void func(int x1, int x2 = 2, int x3 = 3){}
func(10); //等效于func(10,2,3)
func(10, 8); //等效于func(10,8,3)
func(10, , 8); //错误，只能最右边连续若干个缺省
- 1
- 2
- 3
- 4
文章来源: blog.csdn.net，作者：沧夜2021，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/CANGYE0504/article/details/104643359
- 点赞
- 收藏
- 关注作者
评论（0）