C++学习_从C到C++

Wesley13
• 阅读 872

一、引用的概念和应用


1.引用的概念

下面写法定义了一个引用,并将其初始化为引用某个变量。
        类型名 & 引用名 = 某变量名;
        int n = 4;
        int & r = n; // r引用了n,r的类型是 int &
某个变量的引用,等价于这个变量,相当于该变量的一个别名。  

代码示例:

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
    int n = 7;
    int & r = n;
    r = 4;
    cout<<r<<" "<<n<<endl; // 输出 4 4 
    n = 5;
    cout<<r<<" "<<n<<endl; // 输出 5 5 
    return 0;
}

注意点: 1. 定义引用时一定要将其初始化为引用某个变量。
2. 初始化以后,从一而终,不会再引用别的变量。
3. 引用只能引用变量,不能引用常量和表达式。

代码示例:

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
    double a = 4, b = 5;
    double & r = a; // r引用 a 
    double & p = r; // 这时候 p 也引用了 a
    p = 10;
    cout<<a<<" "<<r<<" "<<p; // 输出 10 10 10  
    r = b; // 这句话并不代表r重新引用b,而是把 b值赋值给r  
    cout<<a<<" "<<r<<" "<<p; // 输出 5 5 5  
     
    return 0;
}

课堂习题:

下面程序片段输出结果是什么?
    int a = 1,b = 2;
    int & r = a;
    r = b;
    r = 7;
    cout << a << endl;

2. 引用应用的简单示例

2.1 引用作为函数的参数

C语言中如何交换两个整型变量的值?
void swap(int * a, int * b)
{
    int temp;
    temp = *a; *a=*b; *b=temp;
}
int n1, n2;
swap(&n1, &n2); // n1 n2 的值被交换
 
有了C++的引用:

void swap(int & a, int & b)
{
    int temp;
    temp = a; a=b; b=temp;
}
int n1, n2;
swap(n1, n2); // n1 n2 的值被交换

2.2 引用作为函数的返回值  

// 课堂练习
# include <iostream>
using namespace std;
int n = 4;
int & SetValue()
{
    return n;
}
int main(void)
{
    SetValue() = 40; // 将40的值赋值给SetValue()函数的返回n 
    cout<<n; // 输出40 
    return 0;
}

2.3 常引用 

定义引用时,前面加const关键字,即为“常引用”
int n;
const int & r = n; // r 的类型是const int &
不能通过常引用去修改其引用内容。
int n = 100;
const int & r = n;
r = 200; // 编译错
n = 300; // 没问题

2.4 常引用和非常引用的转换

const T & 和 T & 是不同的类型!
T &类型的引用或者T类型的变量可以用来初始化const T &类型的引用。

而const T类型的常变量和const T &类型的引用则
不能用来初始化T &类型的引用,除非强制类型转化。

二、const关键字


0) 定义常引用 (在引用处已经讲过,不再赘述)

1) 定义常量

const int MAX_VAL = 23;
const double Pi = 3.14;
const char * SCHOOL_NAME = "PKU";

2) 定义常量指针

A) 不能通过常量指针修改其指向内容

int n, m;
const int * p = &n; 
* p = 5; // 试图通过指针修改指向内容, 编译出错
n = 4; // ok 指向的内容本身是可以修改的
p = &m; // ok 常量指针的指向可以发生变化

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

const int * p; // 常量指针
int * q; // 非常量指针
p = q; // ok
q = p; // error 企图把常量指针赋值给非常量指针
q = (int *)p; //ok 强制类型转化

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

// 课堂练习
# include <iostream>
# include <string.h>
using namespace std;

void MyPrintf(const char * p)
{
    strcpy(p,"123"); // 编译出错 
    // 因为strcpy()函数的第一个参数是 char * 非常量指针
    // 而定义的 P 是一个常量指针,所以,赋值过程会报错 
    printf("%s",p);  // ok
}

int main(void)
{
    char ch[5] = {"0123"};
    const char * q = ch;
    MyPrintf(q);
    return 0;
}   

课堂习题:

下面说法哪种是对的?
A) 常引用所引用的变量,其值不能被修改
B) 不能通过常量指针,去修改其指向的变量
C) 常量指针一旦指向某个变量,就不能再指向其他变量
D)  以上都不对

三、动态内存分配


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

1.1) 用new 分配一个变量

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

代码示例:

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
     int * p;
     p = new int; // 给P指针分配内存
     *p = 5;
     cout<<*p;
      
    return 0;
}

课堂习题:

表达式 “new int”的返回值类型是:
A) int
B) int *
C) int &
D) void

1.2) 分配一个数组

P = new T[N];
T: 任意类型名
P: 类型为T * 的指针
N:要分配的数组元素的个数
动态分配出一片大小为N*sizeof(T)字节的内存空间,并且将该内存空间的起始地址赋值给P。

代码示例:

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
    int * p;
    p = new int[20];
    p[10] = 5;
    cout<<p[10]; // 输出5 
      
    return 0;
}

1.3) new 运算符的返回值类型

new T;
new T[N];
均返回T*类型

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

2.1) 用new 动态分配的内存空间,一定要用delete运算符进行释放

delete 指针; // 该指针必须指向new出来的空间
int * p = new int;
* p = 5;
delete p;
delete p; // error,不能delete两次

代码示例:

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
    int * p = new int;
    *p = 5;
    cout<<*p<<endl; // 输出5 
    delete p;
    cout<<*p<<endl; // 输出结果不为 5,空间已经被释放 
    return 0;
}

2.2) 用delete释放动态分配的数组,要加 []

delete [] 指针; // 该指针必须指向new出来的数组
int * p = new int[20];    
p[0] = 1;
delete [] p;

代码示例:

// 课堂练习
# include <iostream>
using namespace std;

int main(void)
{
    int * p = new int[20];
    p[10] = 5;
    cout<<p[10]<<endl; // 输出5 
    printf("%p\n",p[10]); // 输出p[10]的地址 
    delete [] p;    
    cout<<p[10]<<endl; // 输出5,空间已经被释放 
    printf("%p\n",p[10]); // 输出p[10]的地址
    delete [] p; // 再次delete编译不会报错,但是程序无法继续执行    
    cout<<p[10]<<endl; // 无输出
    printf("%p\n",p[10]); // 无输出
    return 0;
}

课堂习题:

下面小段程序,哪个是正确的:
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;
D) 都不对?

四、动态内存分配


1. 内联函数

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

在函数定义前加“inline”关键字,即可定义内联函数 

inline int Max(int a,int b)
{
    if( a > b) return a;
    return b;
}

2. 函数重载

一个或多个函数,名字相同,然而参数个数或参数类型不相同,这叫做函数的重载。

以下三个函数是重载关系:
int Max(double f1,double f2) { }
int Max(int n1,int n2) { }
int Max(int n1,int n2,int n3) { }

函数重载使得函数命名变得简单。编译器根据调用语句的中的实参的个数和类型判断应该调用哪个函数。

具体使用:

(1) int Max(double f1,double f2) { }
(2) int Max(int n1,int n2) { }
(3) 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,二义性

3. 函数的缺省参数

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

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) ; //不行,只能最右边的连续若干个参数缺省

函数参数可缺省的目的在于提高程序的可扩充性。

即如果某个写好的函数要添加新的参数,而原先那些调用该函数的语句,未必需要使用新增的参数,那么为了避免对原先那些函数调用语句的修改,就可以使用缺省参数。

课堂例题:

下面说法正确的是:
A) 多个重载函数的参数个数必须不同。
B) 两个函数,参数表相同,返回值类型不同,它们是重载关系。
C) 调用一个第二个和第三个参数都有有缺省值的函数时,可以不写第二个实参而写第三个实参。
D) 使用内联函数的目的是提高程序的运行速度。

RRR

点赞
收藏
评论区
推荐文章
cpp加油站 cpp加油站
3年前
c++中引用面试点7连问以及引用真的不分配内存吗
本篇文章从面试官的口吻连问7个引用有关的问题,并且从汇编的层面上对引用进行深入分析,让你充分理解引用的概念和原理。首先还是看一下思维导图:1.引用的背景和概念说到引用,首先要说一下'&'标识符,其实c语言中这个符号只是用来取地址的,并没有引用的概念,直到c对这个标识符的作用进行了扩充,才有了引用这个概念。所谓引用,其实就是给变量取了一个别名,一个简单
Wesley13 Wesley13
3年前
java学习笔记3
1 创建引用类型变量公式    数据类型 变量名new数据类型();    变量名.方法名();2 Scanner类的使用!(https://oscimg.oschina.net/oscnet/f0aaacf3774ded91479f8e42c680794aa8c.jpg)!(https://oscimg.oschi
待兔 待兔
3年前
[Dart]Dart语言之旅<二>:变量
变量以下是创建变量并为其分配值的示例:varname'Bob';变量是引用。名为name的变量包含对值为“Bob”的String类型的对象的引用。默认值未初始化的变量的初始值为null。即使是数字类型的变量,初始值也为null,因为数字也是对象。intlineCount;assert(lineCountnull)
xiguaapp xiguaapp
3年前
jvm
类的加载连接与初始化加载:查找并加载类的二进制数据连接验证:确保被加载的类的正确性准备:为类的静态变量分配内存,并将其初始化为默认值解析:把类中的符号引用转换成为直接引用初始化:为类的静态变量赋予正确的初始值主动使用创建类的实例访问某个类或接口的静态变量,或者对该静态变量赋值调用类的
Wesley13 Wesley13
3年前
C++ 引用问题
一个const的对象,调用自身用该都是const式的成员函数,因为非const成员函数可能会更改该对象,与const对象冲突。当然可以加上一个fpermissive参数来稍微放松,但最好不要这样做。右值作为一个非const引用参数,编译器不允许。左值:可以取到地址并且有空间,内容可以改变的
Wesley13 Wesley13
3年前
C++:指针和引用
引用的概念及用法 所谓的引用并不是说重新定义的一个新的变量,而是给一个已经定义好了的变量起的一个别名。 下面看看引用到底是如何使用的:voidtest1(){  inta1;  int&ba;//引用变量b是a的别名  std::cout<<"a:address"<<&a<<std::
Stella981 Stella981
3年前
GO开发[二]:golang语言基础
一.变量1.声明变量变量相当于是对一块数据存储空间的命名,程序可以通过定义一个变量来申请一块数据存储空间,之后可以通过引用变量名来使用这块存储空间。Go语言引入了关键字var,而类型信息放在变量名之后,变量声明语句不需要使用分号作为结束符,示例如下:varv1intvarv2string
Stella981 Stella981
3年前
JVM调优总结一
数据类型   Java虚拟机中,数据类型可以分为两类:基本类型和引用类型。基本类型的变量保存原始值,即:他代表的值就是数值本身;而引用类型的变量保存引用值。“引用值”代表了某个对象的引用,而不是对象本身,对象本身存放在这个引用值所表示的地址的位置。基本类型包括:byte,short,int,long,cha
Wesley13 Wesley13
3年前
Java基础学习总结(21)——数组
一.数组的基本概念数组可以看成是多个相同类型数据组合,对这些数据的统一管理。数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。数组的元素可以是任何数据类型,包括基本类型和引用类型。C和C中的数组都可以分配在栈上面,而JAVA中的数组是只能分配在堆
小万哥 小万哥
6个月前
C++ 引用和指针:内存地址、创建方法及应用解析
C引用和指针创建引用引用变量是对现有变量的“别名”,它是使用&运算符创建的:cstringfood"Pizza";//食物变量string&mealfood;//对food的引用现在,我们可以使用变量名food或引用名meal来引用食物变量:c