C++笔记整理

最新推荐文章于 2021-03-18 22:29:42 发布

DrawnBreak

最新推荐文章于 2021-03-18 22:29:42 发布

阅读量277

点赞数

分类专栏： C/C++基础

本文链接：https://blog.csdn.net/a799581229/article/details/79334479

版权

C/C++基础专栏收录该内容

11 篇文章 1 订阅

订阅专栏

把自己印象笔记中所记录的一些C++知识点整合了一下，可用于面试前对C++知识的快速回顾。

不过并不全，只是自己笔记中的摘要，重要的还是系统和踏实地学习。

每个知识点不分顺序。

1.typeid是什么

typeid用于类的类型检查

检查是否是同一类型

一般用于指针类

D d;

C *p=d;

typeid(*p)==typeid(D)则满足

返回类型是type_info

2.define的一些注意点

 
  #define a 10 
 

 
 void 
   
 foo();

 
  main(){ 
 

 
     
 printf 
 ( 
 "%d.." 
 ,a); 

 
     
 foo(); 

 
     
 printf 
 ( 
 "%d" 
 ,a); 

}

 
 void 
   
 foo(){

 
  #undef a

 
  #define a 50    
  //只影响这句话之后的内容

 
  } 
 
  答案输出10..10 
 
  另外，不管是在某个函数内，还是在函数外，define都是从 
  定义开始直到文件结尾 
  ，所以如果把foo函数放到main上面的话，则结果会是50 ，50

 
        #define a 10 
       

 
        void 
          
        foo();

 
        void 
          
        prin();

 
        prin();

 
        printf 
        ( 
        "%d " 
        , a);

 
        foo();

 
        printf 
        ( 
        "%d " 
        , a);

}

 
        #undef a 
       

 
        #define a 50 
       

}

 
        void 
          
        prin() 
        {

 
              
         printf 
         ( 
         "%d " 
         , a);   
         //此处的a已经被替换 
        

}

上面代码输出 50 10 10，可以看出define只是在预处理阶段将a替换为相应数值，具体替换的值,只与define在文件中的位置有关，与是否在函数内无关。

3.重载，重定义，重写是什么？

1.重写(override):

父类与子类之间的多态性。子类重新定义父类中有相同名称和参数的虚函数。

1)被重写的函数不能是static的。必须是virtual的(即函数在最原始的基类中被声明为virtual )。

2)重写函数必须有相同的类型，名称和参数列表(即相同的函数原型)

3)重写函数的访问修饰符(public...)可以不同。尽管virtual是private的，派生类中重写改写为public,protected也是可以的

2.重载(overload):

指函数名相同，但是它的参数表列个数或顺序，类型不同。但是不能靠返回类型来判断。

3.重定义(redefining):

子类重新定义父类中有相同名称的非虚函数(参数列表可以不同)。

重写与重载的区别 (override) PK (overload)

1、方法的重写是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。

2、重写要求参数列表相同；重载要求参数列表不同。

3、重写关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；

重载关系，是根据调用时的实参表与形参表来选择方法体的。

4.C++中的空类，默认产生哪些类成员函数？

class Empty

{

public:

Empty(); // 缺省构造函数

Empty( const Empty& ); // 拷贝构造函数

~Empty(); // 析构函数

Empty& operator=( const Empty& ); // 赋值运算符

Empty* operator&(); // 取址运算符

const Empty* operator&() const; // 取址运算符 const

};

5.运算符重载

规则：

不可重载"." 或"*"，这2个是用来访问成员的

不可重载“：：”，作用域分辨符的操作数是类型

不可重载“？”，是三目运算符

返回类型 operator 运算符（形参） {

函数体

}

成员函数的运算符重载比非成员函数少一个形参

因为自身this就是一个

重载自加运算符后可以返回对象的引用，以方便在表达式中连续使用。

举个例：

cout<<其实是重载了<<这个操作符，cout是一个ostream的对象。如果不返回引用，cout<<a<<b<<endl;

若不是引用，则cout<<a就不是一个输出流对象，就无法继续接b在屏幕上输出了。

就不可以一起写了。如果返回自身的引用 cout<<a之后，返回身身的引用，后面可以继续接b了。就是这个意思吧。好多重载操作符，作用其实都是这样的。

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

class z;
ostream & operator<< (ostream &out,z z1);

class z{
public:
    int real,imag;
    z(int r=0,int i=0):real(r),imag(i){};
    z operator+ (const z &z1) const;
    z operator- ();//无参数，前置负号
    z &operator++ () ; //前置，即++z
    z operator++ (int) ; //后置，即z++
    friend ostream & operator<< (ostream &out,z z1);
    void show();
};

//友元函数，不用加::
ostream & operator<< (ostream &out,z z1)
{
    out<<"("<<z1.real<<","<<z1.imag<<")";
    return out;
}

z z::operator+ (const z &z1) const
{
    return z(this->real+z1.real,imag+z1.imag);
}

z &z::operator++ ()
{
    real++;
    imag++;
    return *this;
}

z z::operator++ (int )
{
    return z(real++,imag++);
}

z z::operator- ()
{
    return z(-real,-imag);
}
void z::show()
{
    printf("(%d,%d)\n",real,imag);   
}
int main()
{
    z a(1,5),b(3,1);
    cout<<"a+b=";
    (a+b).show();
    (a++).show();
    a.show();
    (++b).show();
    b.show();
    (-b).show();
    cout<<"a="<<a<<endl;
}

6.模板类和类模板的区别

模板定义：模板就是实现代码重用机制的一种工具，它可以实现类型参数化，即把类型定义为参数，从而实现了真正的代码可重用性。模版可以分为两类，一个是函数模版，另外一个是类模版。

Template <class或者也可以用typename T>

返回类型函数名（形参表）

{//函数定义体 }

//声明一个函数模版,用来比较输入的两个相同数据类型的参数的大小，class也可以被typename代替，
//T可以被任何字母或者数字代替。
template <class T>
T min(T x,T y)
{
return(x<y)?x:y;
}

模板类和重载函数一起使用时：

两者一起使用时，先考虑重载函数，后考虑模板类，如过再找不到，就考虑类型转换，可能会带来精度的变化。

类模板：

template <class T>
class Base
{
public :
T a ;
Base(T b) {
a = b ;
}
T getA(){ return a ;} //类内定义
void setA(T c);
};
template <class T> //模板在类外的定义
void Base<T>::setA(T c)
{
a = c ;
}

7.static 和 const 的作用

static关键字至少有下列5个作用：

（1）函数体内变量。函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；

（2）模块内全局变量。在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；

（3）模块内函数。在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；

（4）类内成员变量。在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；

（5）类内成员函数。在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

const关键字至少有下列n个作用：

（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；

（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；

（3）在一个函数声明中， const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；

（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；

（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：

const classA operator*(const classA& a1,const classA& a2);

operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：

classA a, b, c;

(a * b) = c; // 对a*b的结果赋值

操作(a * b) = c显然不符合编程者的初衷，也没有任何意义。

8.String类的实现

编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

 
         class 
           
         String 
         {

 
         public 
         :

 
         String( 
         const 
           
         char 
           
         *str = NULL);  
         // 普通构造函数

 
         String( 
         const 
           
         String &other);  
         // 拷贝构造函数

 
         ~ String( 
         void 
         );  
         // 析构函数

 
         String & operator =( 
         const 
           
         String &other);  
         // 赋值函数

 
         private 
         :

 
         char 
           
         *m_data;  
         // 用于保存字符串

};

参考答案

 
         //普通构造函数 
        

 
         String::String( 
         const 
           
         char 
           
         *str)  
         {

 
         if 
         (str==NULL)  
           
         {

 
         m_data =  
         new 
           
         char 
         [1];  
         // 得分点：对空字符串自动申请存放结束标志'\0'的空

 
         //加分点：对m_data加NULL 判断

 
         *m_data =  
         '\0' 
         ;

}

 
         else 
         {

 
         int 
           
         length =  
         strlen 
         (str);

 
         m_data =  
         new 
           
         char 
         [length+1];  
         // 若能加 NULL 判断则更好

 
         strcpy 
         (m_data, str);

}

}

 
         // String的析构函数 
        

 
         String::~String( 
         void 
         )  
         { 
        

 
         delete 
           
         [] m_data;  
         // 或delete m_data;

}

 
         //拷贝构造函数 
        

 
         String::String( 
         const 
           
         String &other) 　　　 
         // 得分点：输入参数为const型 
         {  
        

 
         int 
           
         length =  
         strlen 
         (other.m_data);

 
         m_data =  
         new 
           
         char 
         [length+1]; 　　　　 
         //加分点：对m_data加NULL 判断

 
         strcpy 
         (m_data, other.m_data);

}

 
         //赋值函数 
        

 
         String & String::operate =( 
         const 
           
         String &other)  
         // 得分点：输入参数为const型 
         {  
        

 
         if 
         ( 
         this 
           
         == &other) 　　 
         //得分点：检查自赋值

 
         delete 
           
         [] m_data; 　　　　 
         //得分点：释放原有的内存资源

 
         int 
           
         length =  
         strlen 
         ( other.m_data );

 
         m_data =  
         new 
           
         char 
         [length+1]; 　 
         //加分点：对m_data加NULL 判断

 
         strcpy 
         ( m_data, other.m_data );

 
         return 
           
         * 
         this 
         ; 　　　　　　　　 
         //得分点：返回本对象的引用

}

9.assert的作用

参数：Expression (including pointers) that evaluates to nonzero or 0.（表达式【包括指针】是非零或零）

原理：assert的作用是现计算表达式 expression ，如果其值为假（即为0），那么它先向stderr打印一条出错信息，然后通过调用 abort 来终止程序运行。

用法总结：

1) 在函数开始处检验传入参数的合法性

如:

int resetBufferSize(int nNewSize)

{

//功能:改变缓冲区大小,

//参数:nNewSize 缓冲区新长度

//返回值:缓冲区当前长度

//说明:保持原信息内容不变 nNewSize<=0表示清除缓冲区

assert (nNewSize >= 0);

assert (nNewSize <= MAX_BUFFER_SIZE);

...

}

2) 每个assert只检验一个条件 , 因为同时检验多个条件时,如果断言失败,无法直观的判断是哪个条件失败

不好: assert (nOffset>=0 && nOffset+nSize<=m_nInfomationSize);

好: assert (nOffset >= 0);

assert (nOffset+nSize <= m_nInfomationSize);

3) 不能使用改变环境的语句, 因为 assert 只在DEBUG个生效,如果这么做,会使用程序在真正运行时遇到问题

错误: assert (i++ < 100)

这是因为如果出错，比如在执行之前i=100,那么这条语句就不会执行，那么i++这条命令就没有执行。

正确: assert (i < 100)；

i++;

4) assert和后面的语句应空一行 ,以形成逻辑和视觉上的一致感

5)有的地方, assert 不能代替条件过滤

ASSERT 只有在Debug版本中才有效，如果编译为Release版本则被忽略掉。（在C中， ASSERT 是宏而不是函数），使用 ASSERT “断言”容易在debug时输出程序错误所在。

而 assert ()的功能类似，它是ANSI C标准中规定的函数，它与 ASSERT 的一个重要区别是可以用在Release版本中。

使用 assert 的缺点是，频繁的调用会极大的影响程序的性能，增加额外的开销。

在调试结束后，可以通过在包含#include < assert .h>的语句之前插入 #define NDEBUG 来禁用 assert 调用，示例代码如下：

[cpp] view plain copy print ?

void* memcpy(void *dst, const void *src, size_t count)
{
//安全检查
assert( (dst != NULL) && (src != NULL) );
unsigned char *pdst = (unsigned char *)dst;
const unsigned char *psrc = (const unsigned char *)src;
//防止内存重复
assert(!(psrc<=pdst && pdst<psrc+count));
assert(!(pdst<=psrc && psrc<pdst+count));
while(count--)
{
*pdst = *psrc;
pdst++;
psrc++;
}
return dst;
}

10.函数指针的用法

int max(int a,int b) {

cout<<a+b<<endl;

return a+b;

}

int (*p)(int,int)=max;

int main() {

(*p)(1,2); //都可以！

p(1,2);

}

函数指针

Int and(int a,int b){return a+b;}

int (*p)(int ,int );

p=and;

int c=(*p)(1,2);

11.枚举变量

枚举元素不是字符常量也不是字符串常量，使用时不要加单、双引号。

只能把枚举值赋予枚举变量，不能把元素的数值直接赋予枚举变量

enum e{a,b,c=5,d,e} x;

int main()
{
    char *s="abcde";
    x=(enum e)d;      //d代表6，a代表0，b代表1
    switch(x)
    {
        case a:cout<<"a"<<endl;break;
        case b:cout<<"b"<<endl;break;
        case c:cout<<"c"<<endl;break;
        case d:cout<<"d"<<endl;break;
        case e:cout<<"e"<<endl;break;
    }
}

12.构造函数析构函数是不是虚函数

1. 为什么构造函数不能为虚函数？

虚函数的调用需要虚函数表指针，而该指针存放在对象的内容空间中；若构造函数声明为虚函数，那么由于对象还未创建，还没有内存空间，更没有虚函数表地址用来调用虚函数 ——构造函数了。

2. 为什么析构函数可以为虚函数，如果不设为虚函数可能会存在什么问题？

首先析构函数可以为虚函数，而且当要使用基类指针或引用调用子类时，最好将基类的析构函数声明为虚函数，否则可以存在内存泄露的问题。

举例说明：

子类B继承自基类A； A *p = new B; delete p;

1）此时，如果类A的析构函数不是虚函数，那么delete p； 将会仅仅调用A的析构函数，只释放了B对象中的A部分，而派生出的新的部分未释放掉。

2）如果类A的析构函数是虚函数，delete p; 将会先调用B的析构函数，再调用A的析构函数，释放B对象的所有空间。

补充： B *p = new B; delete p;时也是先调用B的析构函数，再调用A的析构函数

13.特殊类型变量

如果一个变量被频繁使用，需保存在寄存器中，因为寄存器的速度要比内存快的许多。在早期的编译器中需要手动定义为register型，但是后来编译器可以自动将调用次数多的变量放入寄存器中。

auto: 默认的分配类型。一般不需要手动声明了，C++11特性；

auto s="abc",ss="edf" //auto变成string

auto a=1,*p=2 //相当于aoto变成int

auto a=1,c="abc" //出错，2者类型不一致

static：静态分配内存。变量在整个作用域内是全局变量。

extern : 声明为外部变量；在函数的外部定义变量；

Volatile

修饰符，修饰后的变量可以防止被编译优化，每次取值时会逐语句取值（多线程）

14.二重指针寻址

 
      #include <stdio.h> 
     

 
      void 
        
      f( 
      char 
      **p){

}

 
      main() 
     

{

 
           
      char 
        
      *a[] = { 
      "123" 
      , 
      "abc" 
      , 
      "456" 
      },**p; 
     

 
      p = a;

 
      f(p);

 
      printf( 
      "%s\r\n" 
      ,*p);

 
       } 
      
       输出3 
      
       *p+=2;就相当于*p=*p+2; 
      
       其中*p指向字符串“123”的第一个元素，即‘1’，指针p向后移两个元素的地址，即指向‘3’ 
      
        而*(p+2)才是基于p每次向后移一个字符串的长度，即*(p+2)指向“456”

15.STL一级容器

STL中一级容器是指, 容器元素本身是基本类型, 非组合类型。(vector, deque, list.)

set, multiset中元素类型是pair<key_type, key_type>;

map, multimap中元素类型是pair<key_type, value_type>;

16.多重继承的优缺点

多继承或者继承都是为了实现类的重用和封装，优点就是减少代码量，实现算法抽象等；缺点（多继承）就是容易造成名字空间冲突（尤其对于MFC类或者其他同一个基类的一般不能使用多继承），或者所称的菱形继承。建议看看《设计模式》这本书，一般可以通过其他方法（聚合等）实现多继承的话应该避免多继承。

17.动态联编（多态）

动态联编就是程序在运行的时候知道该调用哪个函数，而不是编译阶段，所以这个机制应该是由虚函数支持的，即运行时的多态。

基类的某个成员函数声明为虚函数，派生类继承，而且同样重写该函数，那么当声明一个派生类的指针或者引用时，它所调用的函数是由该指针指向的对象确定的，这就是动态联编

多态：指当不同的对象收到相同的消息时，产生不同的动作

编译时多态：函数重载、运算符重载——静态绑定

运行时多态：虚函数机制——动态绑定

C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。

18.转义字符

\0 空字符(NULL) 000

\ddd 任意字符三位八进制（不可有大于7的数字！）

\xhh 任意字符二位十六进制

一般转义字符，如‘\b’，由两个字符表示，其实代表一个字符，这个代表退格字符

19.重载的注意事项

重载只要求函数名相同，参数类型和个数不同，对返回值类型不做要求

不能重载‘.’，因为‘.’在类中对任何成员都有意义，已经成为标准用法。

不能重载 ?: ，因为这个运算符对于类对象来说没有实际意义，相反还会引起歧义

还有：：

20.指针数组

int fun(int *p[4]),

p是包含4个指针的数组。

int a[4][4]作为形参不符合，因为他指向的内容是数组，而不是指针

int **a 二级指针，指针指向的内容还是指针，对的

int D[4][8] 对应的形参为

int(*s)[8] ( 数组指针，每个都指向对应的数组的每列)

或

int D[][8]

1、int(*p)[4];------ ptr 为指向含4个元素的一维整形数组的指针变量（是指针）对应4个元素数组的指针

2、int *p[4];-------定义指针数组p，它由4个指向整型数据的指针元素组成（是数组）

对应指针的数组

3、int(*)[4];--------实际上可以看作是一种数据类型。也就是第一个（int(*p)[4];）

21.数组取地址的问题

a[]={1,2,3,4,5}

此时，a指代数组的首地址

而&a指代的是也是数组首地址，但是会把数组a看作一个整体

(int　＊)（&a+1）则指数组最后一个元素的下一个

以下代码的输出是（2 ， 5）

1

2

3

 
        int 
        *ptr=( 
        int 
        *)(&a+ 
        1 
        ); 
       

 
         printf( 
         "%d,%d" 
         ,*(a+ 
         1 
         ),*(ptr- 
         1 
         )); 
        
           int a[5]={0,1,2,3,4}; 
        
           cout<<*(a++)<<endl; //此处a++是错的 
        
         作为数组名，a是一个 
         常量指针 
         ，a指向的内容可改，但是a指针的指针地址不可改。 
        
         应该让int *p=a，那么即可执行p++ 
        
         当a传入函数时，退化为指针，那么就可以执行a++了 
        
         char *b="abc" 
        
         则*b="123"是错的，内容不可改，指向可改。 
        
         但b=c是对的。

22.读文件时的定位问题

 
         #include <stdio.h> 
        

 
         main() 
         {

 
         FILE * fp;

 
              
         fp = fopen( 
         "data.dat" 
         , 
         "w+" 
         ); 
        

 
          fseek(fp,0L, 
          0 
          );           //移动到文件开头，偏移0

 
          fprintf(fp, 
          "%d\n" 
          ,a[i]);  //

 
          rewind (fp);    //也是回到文件开头

 
         fscanf(fp, 
         "%d" 
         ,&k);

}

 
         fclose(fp);

 
         printf( 
         "%d\n" 
         ,k);

则程序的输出结果是?

如果来看解析的话，估计这道题难点在于fseek和rewind两个函数不太了解。

fseek（文件，偏移量，类别）改变指针函数，,其中类别为文件开头 0，文件当前位置 1，以及文末 2。

所以，fseek(fp,0L,0)就是把文件指针fp移到里开头0字节的地方，即开始位置。

rewind相当于fseek(fp,0L,0)，由此可见出题人内心腹黑，强行多考一个函数。

代码循环内流程如下：移到开始位置->写一个数字->移到开始位置->读一个数字（恰恰是刚才写的那个）循环。

23.结构体大小判断

32位和64位系统的区别在于long和指针，32位下他们是4字节，64位下他们是8字节
short都是2字节，float都是4字节，double都是8字节，long long都是8字节
short int 2字节
long long int 8字节
遵循两条原则：一、结构体变量中成员的偏移量必须是成员大小的整数倍（0被认为是任何数的整数倍）
二、结构体大小必须是所有成员大小的整数倍。
struct A{
longa1;
shorta2;
inta3;
int*a4;
};
例如求上面这个结构体A的sizeof大小，在64位下
a1的移量为0，长度为8
a2的偏移量为0+8=8，长度为2
a3的偏移量为8+2=10，不符合int长度4的倍数，故偏移量变成12,，长度为4
a4的偏移量为12+4=16，长度为8
故总大小为16+8=24,24是所有成员大小的整数倍，故A的大小为24