程序员面试秘笈③"/>
C和C++程序员面试秘笈③
本系列博客基于董山海的<C和C++程序员面试秘笈>,旨在记录,欢迎交流,可联系 zywang@shu.edu !
第三章:引用和指针
文章目录
- 1、面试题1
- 2、面试题2
- 3、面试题3
- 4、面试题4
- 5、面试题5
- 6、面试题6
- 7、面试题7
- 8、面试题8
- 9、面试题9
- 10、面试题10
- 11、面试题11
- 12、面试题12
- 13、面试题13
- 14、面试题14
- 15、面试题15
- 16、面试题16
- 17、面试题17
- 18、面试题18
1、面试题1
一般变量引用
#include <iostream>
#include <string>
using namespace std;int main(int argc, char* argv[]) {int a = 10, b = 20;int &rn = a; //声明 rn 是变量 a 的一个引用,也就是 rn 是 a 的一个别名int equal;//rn = b;cout << "a =" << a << endl;cout << "b =" << b << endl;//rn = 100;//cout << "a =" << a << endl;cout << "b =" << b << endl;//equal = (&a == &rn) ? 1 : 0;cout << "equal = " << equal << endl;system("pause");return 0;
}
2、面试题2
指针变量引用
引用类型的变量在声明的同时必须初始化
#include <iostream>
using namespace std;int main(int argc, char* argv[]) {int a = 1;int b = 10;int *p = &a; //这一行的意思是声明整型的指针变量P,并指向a,也就是p指向aint* &pa = p; //声明p的一个指针引用pa(*pa)++; //将引用里面的值加1pa = &b; //将pa指向变量b的地址,由于pa也是p的引用,此时p也指向了b(*pa)++;return 0;
}
3、面试题3
交换两个字符串
#include <iostream>
#include <string>//利用传指针引用实现字符串交换
void swap(char *&x, char *&y) {char *temp;temp = x;x = y;y = temp;}
4、面试题4
指针和引用的区别
- 初始化要求不同:引用在创建的同时必须初始化,即引用到一个有效的对象;而指针在定义的时候不必初始化,可以在定义后面的任何地方重新赋值;
- 可修改性不同。引用一旦被初始化为指向一个对象,它就不能被改变为另一个对象的引用;而指针在任何时候都可以改变为指向另一个对象;
- 不存在NULL引用,引用不能使用空值的引用,而指针可以是NULL;
引用比传指针安全的原因:
1、 引用一旦初始化指向一个对象,不能再改变了;
2、 指针随时指向别的对象,并且可以不被初始化,或为NULL。
5、面试题5
复杂指针的声明
int a; //定义一个整数
int *a; //一个指向整数型的指针
int **a; //一个指向指针的指针,它指向的指针的指针指向一个整型数的
int a[10]; //定义一个整数型的数组
int *a[10]; //一个有10个指针的数组,该指针指向整数
int(*a)[10]; //一个指向有10个整型数数组的指针
int(*a)(int); //一个指向函数的指针,该函数有一个整型参数并返回一个整型数
int(*a[10])(int); //一个有10个的指针数组,该指针指向一个函数,函数有一个整型参数并返回一个整型数;
6、面试题6
复杂指针的阅读
- 解读复杂指针声明:从未定义的标识符开始阅读,而不是从括号开始阅读;
- 如: i n t ( ∗ f u n c ) ( i n t ∗ p ) int \ (*func)(int \ *p) int (∗func)(int ∗p) 表示:未定义的标识符为 f u n c func func,左边为一个*号,说明 f u n c func func 是一个指针;跳出圆括号,先看右边,也是一个圆括号,这时候 ( ∗ f u n c ) (*func) (∗func) 是一个函数,而 f u n c func func 是指向这个函数的指针,也就是函数指针,这个函数的形参是 i n t ∗ int* int∗ 类型,返回值为 i n t int int 类型。
- i n t ( ∗ f u n c ) ( i n t ∗ p , i n t ( ∗ f ) ( i n t ∗ ) ) int (*func)(int \ *p,int \ (*f)(int \ *)) int(∗func)(int ∗p,int (∗f)(int ∗)): f u n c func func 是一个指向函数的指针,该指针函数的形参为: i n t ∗ int * int∗ 和 i n t ( ∗ ) ( i n t ∗ ) int(*)(int*) int(∗)(int∗),返回值为 i n t int int 类型。再看看 f u n c func func 的形参 i n t ( ∗ f ) ( i n t ∗ ) int \ (*f)(int \ *) int (∗f)(int ∗),这表示 f f f也是一个函数指针;
- i n t ( ∗ f u n c [ 5 ] ) ( i n t ∗ p ) int (*func[5])(int \ *p) int(∗func[5])(int ∗p): f u n c func func 是一个具有5个元素的数组,且元素为指针,形参为: i n t ∗ p int \ *p int ∗p;
- i n t ( ∗ ( ∗ f u n c ) [ 5 ] ) ( i n t ∗ p ) int \ (*(*func)[5])(int \ *p) int (∗(∗func)[5])(int ∗p): f u n c func func 为一个指针,指向数组的指针,数组的元素是指向指针;
- i n t ( ∗ ( ∗ f u n c ) ( i n t ∗ p ) ) [ 5 ] int \ (*(*func)(int \ *p))[5] int (∗(∗func)(int ∗p))[5]: f u n c func func 是一个函数指针,这类函数具有 i n t ∗ int* int∗ 类型的形参,返回值是指向数组的指针,所指向的数组元素具有5个int元素的数组;
7、面试题7
指针加减操作
对指针 + 1 +1 +1表示:得到下一个元素的地址,而不是原有的地址值直接加1。所以对一个类型为 t 的指针的移动,以 sizeof(t) 为移动单位。
#include <stdio.h>
#include <vector>
#include <iostream>
using namespace std;int main() {int a[5] = { 1,2,3,4,5 }; //声明一个一维数组int *ptr = (int *)(&a + 1); //这边注意的是(a+1)和(&a+1)的地址不一样,&a+1表示下一个对象的地址//printf("%d\n", *(a + 1));printf("%d\n", *(ptr-1));system("pause");return 0;
}
8、面试题8
指针常量与常量指针的区别
常量指针:指向常量的指针,本身可以修改,指针所指向的内容是不容修改的;
指针常量:指针的常量,不可修改地址的指针,但是可以对它所指向的内容进行修改;
如果const位于*号的左侧,用const来修饰指针所指向的变量,即指针指向为常量;
如果const位于*号的右例,const修饰指针本身,即指针本身是常量;
//指针常量,不可修改地址的指针,但是可以对它所指向的内容进行修改
char * const p1;
//常量指针,地址不可被修改,内容可被修改
char const * p2;
//常量指针
const char *p3;
//常量,并且它指向的内容也不能修改
const char *constp4;
9、面试题9
this指针
类的非静态成员函数属于类的对象,只有他含有this指针;而类的static函数属于类本身,友元函数是非成员函数,不含this指针。
10、面试题10
指针数组:一个数组内存放的都为同一类型的指针;
数组指针:一个指针,指向一个数组的地址;
指针函数:返回指针类型的函数。带指针的函数,本质是一个函数,返回类型是某一类型的指针。定义如下:
返 回 类 型 标 识 符 ∗ 返 回 名 称 ( 形 式 参 数 表 ) 函 数 体 返回类型标识符 \ *返回名称(形式参数表){函数体} 返回类型标识符 ∗返回名称(形式参数表)函数体
#include <iostream>
using namespace std;int max(int x, int y) {return (x > y ? x : y);
};//函数find()被定义为指针函数,函数p被定义为函数指针类型
float *find(float *p, int x) {return p + x;
}int main() {float score[] = { 10,20,30,40 };int(*p)(int, int);float *q = find(score + 1, 1); //这边score为地址,返回的是地址int a;//p = max; //p被赋值为max函数的地址a = (*p)(1, 2);//cout << "a = " << a << endl;cout << "*q = " << *q << endl;system("pause");return 0;
}
函数指针:指向函数地址的指针;
下面总结:
-
含10个元素的指针数组:int *a[10];
-
数组指针:int *a= new int[10];
-
函数指针:void (*fn)(int,int);fn是指向 void max(int x,int y)类型的函数指针;
-
指向函数的指针数组: int (*fnArray[10])(int,int);
-
const指针:const int *p;
-
指向const的指针:int* const p;
-
指向const的const指针:const int * const p;
11、面试题11
函数指针的使用:
#include <stdio.h>
#include <algorithm>
//
int add1(int a1, int b1);
int add2(int a2, int b2);
//
int main(int argc, char* argv[]) {int numa1 = 1, numb1 = 2;int numa2 = 2, numb2 = 3;int(*op[2])(int a, int b); //定义了一个函数指针数组,含有两个指针元素op[0] = add1;op[1] = add2;printf("%d %d\n", op[0](numa1, numb1), op[1](numa2, numb2));getchar();system("pause");return 0;
}int add1(int a1, int b1) {return a1 + b1;
}int add2(int a2, int b2) {return a2 + b2;
}
12、面试题12
typedef用于函数指针的定义:
//定义了pfun类型,表示一个函数指针类型
typedef int(*pfun)(int x, int y);
//定义了一个函数
int fun(int x, int y);
//定义了一个pfun类型的函数指针p,并赋给它fun的地址
pfun p = fun;
int ret = p(2, 3);
13、面试题13
野指针:
野指针不是NULL指针,而是指向垃圾内存的指针。其成因主要为:指针变量没有初始化,或指针p被free或者delete之后,没有置为NULL。
14、面试题14
有了malloc/free,为什么还要new/delete?
前者是C++/C的标准库函数,后者为C++的运算符。它们都可以申请动态内存和释放内存!对于非内部数据类型的对象而言,只能用new/delete。
15、面试题15
有了malloc/free,为什么还要new/delete?
前者是C++/C的标准库函数,后者为C++的运算符。它们都可以申请动态内存和释放内存!对于非内部数据类型的对象而言,只能用new/delete。
16、面试题16
各种内存分配和释放的函数的联系和区别
C语言的标准内存分配函数:malloc、calloc、realloc、free等。
malloc与calloc的区别:1块与n块的区别;
malloc的调用形式为:(类型)malloc(size):在内存的动态存储区中分配一块长度为“size”字节的连续区域,返回该区域的首地址,此时内存中值没有初始化,是个随机数*;
calloc的调用形式为:(类型) calloc(n,size):在内存的动态存储区分配n块长度为"size"字节的连续区域,返回首地址,此时内存中的值都被初始化为0*;
realloc的调用形式为:(类型)realloc(ptr,size):将ptr内存大小增大到size,新增加的内存块没有初始化;
*free的调用形式为:free(void ptr):释放ptr所指向的一块内存空间;
17、面试题17
内存分配方式有几种?
- 从静态存储区域分配。内存在程序编译的时候就已经分配好,这块内存在程序的整个运行期间都存在,例如全局变量;
- 在栈上创建。执行函数的时候,局部变量的存储单元可以在栈上创建,执行结束后这些单元自动被释放;
- 在堆上分配,也叫动态内存分配。程序在运行的时候用malloc或者new申请任意多少的内存,并且自己负责free或者delete。
18、面试题18
什么是句柄?
句柄是来标识项目的,例如:module、task、instance、file、block of memory、menu、control、front、resource、GDI对象等。
在windows编程中会用到大量的句柄,比如HINSTANCE(实例句柄)、HBITMAP(位图句柄)、HDC(设备描述表句柄)、HICON(图标句柄),还有一个通用的句柄,就是HANDLE。
句柄地址(稳定)->记载着对象在内存中的地址->对象在内存中的地址(不稳定)->实际对象。
指针与句柄的区别:
指针:对应着一个数据在内存中的地址,得到指针之后可以自由的修改该数据。而句柄是一个指向指针的指针。句柄和指针都是地址,不同之处在于:
- 句柄所指的可以是一个很复杂的结构,并且很可能与系统有关的。比如说线程的句柄,这个十分常见。线程的句柄指向一个类或者结构,它和系统有着很密切的关系。当一个线程由于不可预料的原因而终止是,系统就可以返回它所占用的资料,如GPU、内存等。句柄中的某一项是与系统进行交互。
- 指针也可以指向一个复杂的结构,但需要用户自己定义,所需要的工作用户自己完成,特别是删除的时候。
更多推荐
C和C++程序员面试秘笈③
发布评论