C/C++易错知识点（九推）

布满荆棘的人生 2022-01-07 20:11 260阅读 0赞

\*\*写在前面：\*\*这篇博文是为接下来九推的笔面试做准备的，用来记录自己模糊易错的知识点，会不断整理，删掉掌握的，增加不熟悉的，一直更到保研结束为止。

--------------------

*  当除运算的时候，如英国要保留两位小数的，记得把被除数`*1.0` 不然除出来时整数的`printf("%.2f\n",1.0*sum/k);`
 *  c语言的输入与输出

scanf("%d%d",&c,&d);      //C语言输入流控制，声明输入类型
    常用类型：
             %d     整型
    		 %ld    长整型
    		 %c     字符
    		 %s     字符串
    		 %f     单精度浮点型
    		 %lf    双精度浮点型

printf("c+d=%d\n",c+d);   //C语言输出流控制，输出需要声明类型%d，其它的原封输出
    转义字符：
             \n     换行，当前位置移到下一行开头
    		 \a     响铃
    		 \t     水平制表符
    		 \b     退格
    		 \r     回车，当前位置移到本行开头
    		 \f     换页，当前位置移到下一页开头
    		 \0     空字符！！字符串用来表示串尾
    printf("%.8f",c+d);//保留8为小数输出
    
    printf("%d",a);//输出整数a.
    printf("%5d",a);//整数a按5个字符的宽度显示。
    printf("%*d",len,a);//将整数a按len个字符的宽度显示。
    *号告诉printf待打印字符的显示宽度从后面的参数列表中提取，指定是多少就按多少个字符宽度显示。

c保留两位小数输出

#include <stdio.h>
    int main(){ 
    	printf("%0.2f",3.1415926);
    }

c++保留两位小数输出

#include <iostream>
    #include <iomanip>
    using namespace std;
    int main(){ 
    	cout<<fixed<<setprecision(2)<<3.1415926<<endl;
    	return 0;
    }

*  定义二维数组并赋初值时，可以省略第一维大小，但是不能省略第二维大小。
 *  函数模板的格式：

template <class 形参名，class 形参名，......> 返回类型 函数名(参数列表)
        { 
        
        函数体
        }
        
        类模板的格式为：
        
        template<class   形参名 ，class 形参名，…>   class 类名
        
        {  ... };

*  vector基于数组，那么最糟糕要O(n)，set查找，基于树，最糟糕要O（logN），hash\_map用hash值映射，计算一次就ok，也就是O（1），deque队列，把尾部指针向next走一个就ok，O（1）
 *  C语言常用的头文件  
    \#include <assert.h> //设定插入点  
    \#include <ctype.h> //字符处理  
    \#include <errno.h> //定义错误码  
    \#include <float.h> //浮点数处理  
    \#include <fstream.h> //文件输入／输出  
    \#include <iomanip.h> //参数化输入／输出  
    \#include <iostream.h> //数据流输入／输出  
    \#include <limits.h> //定义各种数据类型最值常量  
    \#include <locale.h> //定义本地化函数  
    \#include <math.h> //定义数学函数  
    \#include <stdio.h> //定义输入／输出函数  
    \#include <stdlib.h> //定义杂项函数及内存分配函数  
    \#include <string.h> //字符串处理  
    \#include <strstrea.h> //基于数组的输入／输出  
    \#include <time.h> //定义关于时间的函数  
    \#include <wchar.h> //宽字符处理及输入／输出  
    \#include <wctype.h> //宽字符分类
 *  C语言文件的相关操作  
    https://blog.csdn.net/paobo/article/details/637080
 *  malloc()函数

如何使用？
    
    动态内存分配函数，用来向系统请求分配内存空间。
    当无法知道内存具体的位置时，想要绑定真正的内存空间，
    就要用到malloc（）函数。
    因为malloc只管分配内存空间，并不能对分配的空间进行初始化，
    所以申请到的内存中的值是随机的，
    经常会使用memset()进行置0操作后再使用。　
    
     free(a);//释放掉使用的内存地址　
    
    　　int *p;
    　　p = (int*)malloc(sizeof(int) * 128);
    　　　　//分配128个整型存储单元，并将这128个连续的整型存储单元的首地址存储到指针变量p中
    　　double *pd = (double*)malloc(sizeof(double) * 12);　　
    　　　　//分配12个double型存储单元，并将首地址存储到指针变量pd中
    　　free(p);
    　　free(pd);
    　　p = NULL;
    　　pd = NULL;

*  有关常量const的一些知识点  
    https://blog.csdn.net/he\_\_yuan/article/details/81607804  
    define和const的区别  
    https://blog.csdn.net/weixin\_33966365/article/details/93551415
 *  引用和指针的区别
    
     *  指针保存的是所指对象的地址，引用是所指对象的别名，指针需要通过解引用间接访问，而引用是直接访问；
     *  指针可以改变地址，从而改变所指的对象，而引用必须从一而终；
     *  引用在定义的时候必须初始化，而指针则不需要；
     *  指针有指向常量的指针和指针常量，而引用没有常量引用；

C++相关知识点

*  什么是重载？
 *  运算符重载：是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时导致不同的行为。其中类属关系运算符`.`、成员指针运算符`. *`、作用域分辨符`：：`、三目运算符`？：`不能被重载
 *  函数重载：两个以上的函数，具有相同的函数名，但是形参个数或者类型不同，编译器根据实参和形参的类型及个数的最佳匹配，自动确定调用哪一个函数。
 *  重载函数的形参必须不同，个数不同或者类型不同

面向对象程序设计基本特点：

*  抽象：对具体问题（对象）进行概括，抽出一类对象的公共性质并加以描述。 数据抽象和行为抽象。
 *  封装：将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的函数进行有机结合，形成“类”，其中的数据和函数都是类的成员。
 *  继承：允许程序员在保持原有特性的基础上，进行更具体、更详细的说明。具有特殊的属性和行为。
 *  多态：多态性是指将一段程序能够处理多种类型对象的能力。在C++语言中这种多态性可以通过强制多态、重载多态、类型参数化多态、包含多态4种形式来实现。
    
     *  实现多态的两种方法就是 覆盖和重载
     *  覆盖： 子类重新定义父类的函数。
     *  重载：见上面。
 *  虚函数
    
     *  简单地说，那些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异而采用不同的策略。
     *  类里如果声明了虚函数，这个函数是实现的，哪怕是空实现，它的作用就是为了能让这个函数在它的子类里面可以被覆盖，这样的话，这样编译器就可以使用后期绑定来达到多态了。
 *  隐式转换与显示转换
    
     *  隐式转换是系统跟据程序的需要而自动转换的。
     *  显式转换也叫强制转换，是自己主动让这个类型转换成别的类型。

2019.6.16

*  指针数组（\*string\[\]）:是数组，“指针”修饰这个数组，代表这个数组所有元素都是指针类型，在32位系统中，指针占4个字节。
 *  数组指针（（\*string）\[\]）：是指针，“数组”修饰这个指针，表示这个指针存放着一个数组的首地址，或者说这个指针指向一个数组的首地址。
 *  .c文件经过编译得到.obj（目标文件），然后进行链接得到.exe（可执行文件）
 *  x- -<5的运算顺序是，先x<5，再- - 但是- -操作会在执行下一步操作之前完成，也就是说下一步用到x时，其值已经小1了。
 *  array. sort(sortFunction)是按照sortFunction结果大小排序。
 *  构造与析构函数的调用顺序  
    构造：基类构造函数>子类承运变量构造函数>子类构造函数  
    析构：子类析构函数>子类成员变量析构函数>基类析构函数。
 *  运算符优先级  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70]

2019.6.17

*  \#define 宏定义只是替换，只是替换，只是替换，不要自己加小括号
 *  三维数组可以看成是一本书！int `a[3][4][2];` 就是有3页每页4行2列
 *  无符号整数的取值范围是0-255
 *  主要靠什么类型系统可以隐式的转换为float类型，在C/C++中，char，int，long, double都可以，不过会有警告。

2019.6.21

*  求补运算：不考虑符号位，所有都取反+1
 *  求补码：数值位取反+1
 *  与运算（&&）：两边都为1才是1，或运算（|）有一个1就是1，异或运算（^）不同为1，相同为0，具体参照：https://blog.csdn.net/tiansheng1225/article/details/83008261
 *  对于一个频繁使用的短小函数，在C语言中用宏实现，在C++中应用内联函数实现。
 *  对于直接插入排序来说，逆序对越少，需要比较的次数就越少。
 *  n个数值选出最大m个数（3<m<n）的最小算法复杂度是O（n）//堆
 *  成员函数被重载的特征：  
    （1）相同范围（在同一个类中）  
    （2）函数名字相同  
    （3）参数不同  
    （4）virtual关键字可有可无
 *  覆盖是指派生类函数覆盖基类函数，特征是：  
    （1）不同范围（分别位于派生类与基类）  
    （2）函数名字相同  
    （3）参数相同  
    （4）基类函数必须有virtual关键字
 *  隐藏 是指派生类的函数屏蔽了与其同名的基类函数，规则如下：  
    （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）  
    （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

2019.7.19//为九推刷牛客网

*  非 > 算术运算符 > 关系运算符 > &&和|| > 赋值运算符 > 逗号运算符  
    ！、&&、||就是逻辑运算符， 优先级要小于关系运算符（>、<、>=、<=、==、！=）
 *  用extern引用一个已经定义过的全局变量
 *  fread(pt,size,n,fp)指从fp指定的文件中读取长度为size的n个数据项，存入pt所指向的内存区
 *  任何一棵二叉树的叶子结点在前序、中序和后序遍历序列中的相对次序 不发生改变
 *  gets函数是读取字符串，以回车键结束，fgets是读取一行字符，以换行符结束，getc读入一个字符，fgetc读取一个字符，读取一个字节后后移一位
 *  n个节点的完全二叉树，当n为奇数，每一个分支节点都有左右儿子，也就没有度为1的点。  
    当n为偶数，编号最大的那个分支节点只有左儿子，其他分支节点左右儿子都有，也就是会有一个度为1的点。  
    另外，非空二叉树的叶子节点比度为2的节点数量多1，即n0 = n1 + 1
 *  “%s”输出直到’\\0’的字符串
 *  友元函数不含this指针，所以友元函数访问对象中的成员要通过对象名。  
    友元函数可以在类内实现也可以在类外实现

>     类内实现：
>         class A
>         {
>           friend void fun(A &tmp){ 函数体}
>         }
>     
>     类内声明，类外实现：
>         class A
>     {
>         friend void fun(A &);
>       }
>       void fun(A &tmp){ 函数体}

*  整型变量在16位机中占2字节，字符型变量占1字节，浮点型变量占4字节，联合体变量，其所占字节数由联合体中所占字节数最多成员来决定
 *  合法的浮点数有两种表示形式：  
    十进制小数形式。他有数字和小数点组成，必须有小数点。例如（123.）（123.0）（.123）。  
    指数形式。如123e3。字母e（或E）之前必须有数字，e后面的指数必须为整数。  
    规范化的指数形式里面，小数点前面有且只有一位非零的数字。如1.2345e8
 *  数组：连续存储，遍历快且方便，长度固定，缺点移除和添加 需要迁移n个数据或者后移n个数据  
    链表：离散存储，添加删除方便，空间和时间消耗大，双向链表比单向的更灵活，但是空间耗费也更大  
    Hash表：数据离散存储，利用hash算法决定存储位置，遍历麻烦  
    二叉树：一般的查找遍历，有深度优先和广度优先，遍历分前序、中序、后序遍历，效率都差不多，但是如果数据经过排序，二叉树效率还是不错。  
    图：表示物件与物件之间的关系的数学对象，常用遍历方式深度优先遍历和广度优先遍历，这两种遍历方式对有向图和无向图均适用，遍历查找不及前面人一种数据结构
 *  模式串的长度是m，主串的长度是n（m<n），使用KMP算法匹配的时间复杂度是O（m+n）？？

2019.7.20

*  当改变网上某一关键路径上任一关键活动后不一定产生不同的关键路径
 *  路径长度是指路径上各个活动的持续时间之和，路径长度最长的路径称为关键路径
 *  构造函数不可以是虚函数，析构函数可以是虚函数
 *  (1) 除了类属关系运算符"."、成员指针运算符".\*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外，C++中的所有运算符都可以重载。  
    (2) 重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符。  
    (3) 运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。  
    (4) 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。  
    (5) 运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。  
    (6) 运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似，避免没有目的地使用重载运算符。
 *  内联函数在编译时做参数类型检查
 *  fclose是一个函数名，功能是关闭一个流。使用fclose()函数就可以把 缓冲区 内最后剩余的数据输出到内核缓冲区，并释放 文件指针 和有关的缓冲区。 函数原型：int fclose( FILE \*fp ).  
    一次正常的fclose会争取释放FILE指针的相关内容。再次fclose释放已经释放掉了的FILE指针，所以会出错

1.static在C、C++、java内的使用场景和作用。  
https://blog.csdn.net/lq18811566072/article/details/82047637

*  static是金泰修饰符，修饰的静态成员存储在全局区，与全局变量存储在一起，编译后，其所分配的内存会一直存在，直到程序退出内存才会释放这个空间
 *  作用和场景  
    修饰成员变量（静态变量）：静态成员属于类，被这个类的所有实例共享，在内存只有一个拷贝，节省了内存通过类名可以直接访问，十分方便。如果类对象中有需要共享的成员变量，则可以定义为静态变量，  
    修饰成员方法（静态方法）  
    无须每次都要new实例化，因为在编译后就已经分配好了内存，通过 类名.方法 来调用。如果方法内部没有访问到实例数据，则可以定义为静态方法  
    修饰代码块（静态代码块）  
    当jvm加载类时，静态代码块的内容会先于其他代码块执行，且只会被执行一次。可用于给类初始化。

2.多态性在C++、Java内都有哪些体现，两种语言任选一种作答。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70 1]

*  [空格怎么处理][Link 1]

scanf("%[^/n]", str);

*  文件的基本操作，读取输出 写

FILE *fp；
    if((fp=fopen("file_1","r"))==NULL)//打开文件
    { 
    	printf("Cannot open this file/n");
    	exit(0);
    }
    
    //关闭文件
    fclose(fp);
    
    //输入输出
    例如:把从键盘输入的文本按原样输出到名为file_1.dat文件中,用字符@作为键盘输入结束标志.
    #include
    Void main()
    { 
    FILE *fpout;
    char ch;
    if(fpout=fpopen("file_1","w")==NULL)
    { 
    printf("Cannot open this file!/n");
    exit(0);
    }
    ch=getchar();
    while(ch!='@')
    {  fputc(ch,fpout); ch=getchar(); }
    fclose(fpout);
    }
    2.调用getc(或fgetc)函数输入一个字符
    调用形式为:
    ch=getc(pf);
    功能是:从pf指定的文件中读如一个字符,并把它作为函数值返回.
    例如:把一个已存在磁盘上的file_1.dat文本文件中的内容,原样输出到终端屏幕上.
    #include
    void main(){ 
    FILE *fpin;
    char ch;
    if((fpin=fopen("file_1.dat","r"))==NULL)
    {  printf("Cann't open this file!/n");exit(0);}
    ch=fgetc(fpin);
    while (ch!=EOF)
    {  putchar(ch); ch=fgetc(fpin);}
    fclose(fpin);
    }
    
    将一个文件里的内容复制到另一个里面去
    #include <stdio.h>
    void filecopy(FILE*,FILE*);
    void main(int argc, char *argv[])
    { FILE *fpin,*fpout;
    if(argc==3)
    { 
    	fpin=fopen(argv[1],"r");
    	fout=fopen(argv[2],"w");
    	filecopy(fin,fout);
    	fclose(fin);fclose(fpout);
    }else if(argc>3)
    printf("The file names too many!!/n";
    else
    printf("There are no file names for input or output!!/n );
    }
    
    void filecopy(FILE *fpin, FILE *fpout)
    { 
    	char ch;
    	ch=getc(fpin);
    	while(!feof(fpin))
    	{ 
    	putc(ch,fout);ch=getc(fpin);
    }
    }
    
    在磁盘上的test.txt文件中放有10个不小于2的正整数,用函数调用方式编写程序.要求实现:
    1,在被调函数prime中,判断和统计10个整数中的素数以及个数.
    2,在主函数中将全部素数追加到磁盘文件test.txt的尾部,同时输出到屏幕上.
    #include <stdio.h>
    #include <math.h>
    int prime(int a[],int n)
    { 
    int i,j,k=0,flag=0;
    for(i=0;i<n;i++)
     {  for(j=2;j<a[i]/2;j++)
      if(a[i]%j==0)
    {  flag=0; break;}
    else flag=1;
    if(flag)
    { a[k]=a[i];k++;}
    }
    return k;
    }
    void main(){ 
    int n,i,a[10];
    FILE *fp;
    fp=fopen("test1-2.txt","r+");
    for(n=0;n<10;n++)
    fscanf(fp,"%d",&a[n]);
    n=prime(a,n);
    fseek(fp,0,2);//指针定位到文件结尾位置
    for(i=0;i <n;i++)
    { printf("%3d",a[i]);
    fprintf(fp,"%3d",a[i]);
    }
    fclose(fp);
    }

C/C++常考点总结

*  [stl常用函数][stl]
 *  [C与C++的区别][C_C]
 *  [面向对象和面向过程的区别][Link 2]  
    面向过程：procedure oriented programming POP  
    面向对象：object oriented programming OOP

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70]: /images/20211220/f5ae7036f0384093b6435c11aaed8d94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQzMTQ1OTI2_size_16_color_FFFFFF_t_70 1]: /images/20211220/de3f8c00148648aaba89cd72ebe43ea5.png
[Link 1]: https://blog.csdn.net/qq573223251/article/details/52673440
[stl]: https://blog.csdn.net/piaoxuezhong/article/details/54348787
[C_C]: https://blog.csdn.net/bitboss/article/details/62884694
[Link 2]: https://blog.csdn.net/gogokongyin/article/details/51111528