从C到C++

发表于 | 更新于: | 分类于 | 阅读次数: |
字数统计: 1,661字 | 阅读时长 ≈ 7分钟

   因为是非科班出来,由于没有学习过C++,感觉有必要学习一波,这里本人决定先非系统的快速了解一波,然后以后再慢慢学习了解。本人学习的内容来自中国大学:https://www.icourse163.org/learn/PKU-1002029030?tid=1002131033#/learn/announce

引用及其应用

引用的概念

   下面的写法定义了一个引用，并将其初始化为引用某个某个变量。

1
2
int n = 4;
int & r = n; // r引用了n,r的类型是 int &

   某个变量的引用，等价于这个变量，相当于这个变量的一个别名,一个示例如下:

1
2
3
4
5
6
7
int n = 4;
int & r = n;
r = 4;
cout << r; //输出 4
cout << n; //输出 4
n = 5;
cout << r; //输出5

   定义引用时一定要将其初始化成引用某个变量；初始化后，它就一直引用该变量，不会再引用别的变量了；引用只能引用变量，不能引用常量和表达式。

1
2
3
4
5
6
7
double a = 4, b = 5;
double & r1 = a;
double & r2 = r1; // r2也引用 a
r2 = 10;
cout << a << endl; // 输出 10
r1 = b; // r1并没有引用b
cout << a << endl; //输出 5

   引用的示例：

1
2
3
4
5
6
7
void swap( int & a, int & b)
{
int tmp;
tmp = a; a = b; b = tmp;
}
int n1, n2;
swap(n1,n2) ; // n1,n2的值被交换

引用作为函数的返回值:

1
2
3
4
5
6
7
8
int n = 4;
int & SetValue() { return n; }
int main()
{
SetValue() = 40;
cout << n;
return 0;
} //输出： 40

常引用

   定义引用时，前面加const关键字，即为”常引用“。

1
2
int n;
const int & r = n;//r的类型是 const int &

   不能通过常引用去修改其引用的内容:

1
2
3
4
int n = 100;
const int & r = n;
r = 200; //编译错
n = 300; // 没问题

常引用和非常引用的转换

   const T & 和T &是不同的类型！！！
T &类型的引用或T类型的变量可以用来初始化const T &类型的引用。
const T类型的常变量和const T &类型的引用则不能用来初始化T &类型的引用，除非进行强制类型转换。

1
2
3
4
5
6
7
8
9
10
11
12
下面程序片段哪个没错？
A) int n = 4;
int & r = n * 5;
B) int n = 6;
const int & r = n;
r = 7;
C) int n = 8;
const int & r1 = n;
int & r2 = r1;
D) int n = 8;
int & r1 = n;
const int r2 = r1;

分析：答案D，A引用了表达式，只能引用变量；B错在不能通过常引用去修改其引用的内容;C错在const T类型的常变量和const T &类型的引用则不能用来初始化T &类型的引用。

const关键字用法

定义常量

1
2
const int MAX_VAL = 23;
const string NAME = "HuangJie";

定义常量指针

不可通过常量指针修改其指向的内容

1
2
3
4
5
int n,m;
const int * p = & n;
* p = 5; //编译出错
n = 4; //ok
p = &m; //ok, 常量指针的指向可以变化

不能把常量指针赋值给非常量，反过来可以

1
2
3
4
const int * p1; int * p2;
p1 = p2; //ok
p2 = p1; //error
p2 = (int * ) p1; //ok,强制类型转换

函数参数为常量指针时，可避免函数内部不小心改变参数指针所指地方的内容

1
2
3
4
5
void MyPrintf( const char * p )
{
  strcpy( p,"this"); //编译出错
  printf("%s",p); //ok
}

定义常引用

1
2
3
4
int n;
const int & r = n;
r = 5; //error
n = 4; //ok

动态内存分配

用new运算符实现动态内存分配

第一个用法，分配一个变量：

1
P = new T;

T是任意类型名，P是类型为T *的指针。
动态分配出一片大小为sizeof(T)字节的内存空间，并且将该内存空间的起始地址赋值给P,比如：

1
2
3
int *pn;
pn = new int;
* pn = 5;

第二种用法，分配一个数组:

1
P = new T[N]

T:任意类型名
P：类型为T *的指针
N:要分配的数组元素的个数，可以是整型表达式。

动态分配出一片大小为sizeof(T)*N字节的内存空间，并且将该内存的起始地址赋值给P，示例如下:

1
2
3
4
5
int * pn;
int i = 5;
pn = new int[i*20];
pn[0] = 20;
pn[100] = 30;//编译没问题。运行时导致数组越界

用delete运算符释放动态分配的内存

用new动态分配内存空间，一定要用delete运算符进行释放。delete指针：该指针必须指向new出来的空间。

1
2
3
4
int * p = new int;
* p = 5;
delete p;
delete p; //导致异常， 一片空间不能被delete多次

用delete释放动态分配的数组，要加”[]”。delete [ ] 指针：该指针必须指向new出来的数组

1
2
3
int * p = new int[20];
p[0] = 1;
delete [ ] p;

其他

内联函数

   函数调用是有时间开销的。如果函数本身只有几条语句，执行非常快，而且函数被反复执行很多次，相比之下调用函数所产生的这个开销就会比较大。
   为了减少函数调用的开销，引入了内联函数机制。编译器处理对内联函数的调用语句时，是将整个函数的代码插入到调用语句处，而不会产生调用函数的语句。

1
2
3
4
5
inline int Max(int a,int b)
{
   if( a > b) return a;
   return b;
}

函数重载

   一个或多个函数，名字相同，然而参数个数或参数类型不相同，这叫做函数的重载。
以下三个函数是重载关系：

1
2
3
4
5
6
7
8
int Max(double f1,double f2) { }
int Max(int n1,int n2) { }
int Max(int n1,int n2,int n3) { }

Max(3.4,2.5); //调用 (1)
Max(2,4); //调用 (2)
Max(1,2,3); //调用 (3)
Max(3,2.4); //error,二义性

函数的缺省参数

   C++中，定义函数的时候可以让最右边的连续若干个参数有缺省值，那么调用函数时，若相应的位置不写参数，参数就是缺省值。

1
2
3
4
5
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）;//不行，只能最右边连续若干个值缺省。

   函数参数可缺省的目的在于提高程序的可扩充性。
   即如果某个写好的函数要添加新的参数，而原来那些调用该函数的语句，未必需要使用新增的参数，那么为了避免对原来那些函数调用语句的修改，就可以使用缺省参数。

0%