码迷,mamicode.com
首页 > 编程语言 > 详细

C++msbs

时间:2020-04-30 19:27:15      阅读:65      评论:0      收藏:0      [点我收藏+]

标签:临时对象   复制   set   deque   img   属性   表示   iterator   rtu   

 

1. 虚函数与纯虚函数

  虚函数是允许被派生类重新定义的成员函数

virtual 返回类型 func(参数); 
virtual 返回类型 func(参数)=0;

  虚函数是为了实现动态绑定(基类能创建自己的对象)

  纯虚函数使一个类称为抽象类(不能创建对象的类,即这个类只是作为一个模型出现),派生类只继承这个接口

 

2. 基类析构函数声明为虚函数

  为了防止内存泄漏。通过父类指针去销毁子类对象时,如果析构函数不是虚函数,则不会触发动态绑定,只调用基类析构函数回收了基类对应的空间,派生类的析构函数没有被调用。

 

3.  自增运算符

  i++:创建临时变量存储i的值,i增加1,然后返回临时变量的值

  ++i:i增加1,返回这个i(并且这个表达式是左值)

 

4. vector

(1)size和capacity

  size指的是当前实际元素个数

  capacity指的是vector中能容纳的元素个数

(2)

  reserve让容器预留空间,增加了vector的capacity,没有改变size

  resize需要两个参数(容器新的大小,新插入元素),如果没有第二个参数,就用默认构造函数插入这个元素,vector的size被改变了

 

5.  关于类里面 const、static

  static对变量产生的作用:

  对局部变量,改变了其存储位置和生命期。存储位置从栈中变成静态存储区,其生命原来是随着语句块结束而消失,加了static则在整个程序运行期间都存在。但其作用域是没有改变的。

  对全局变量,改变了其作用域,使得该变量只在本文件内可见

 

(1)static数据成员的初始化

  static数据成员存储在静态存储区上, 而不是栈上

  static数据成员的初始化要在类体外面(静态成员属于整个类,而不属于某个对象,如果在类里面初始化,会导致每个对象都包含这个静态成员)

  不能在头文件中初始化(会导致重复定义)

  static变量在main函数之前初始化(普通全局变量、静态全局变量、类静态成员变量都在main之前初始化)

  static成员可以成为成员函数的参数

(2)const数据成员

  const成员变量意思是对每个对象而言,它是常量且每个对象的这个值可以不同,但对类而言是可变的

  const成员变量只能用构造函数初始化列表的方式初始化

(3)static const数据成员

  static const整型可在类内初始化

  static const其他类型包括浮点等要在类外初始化

 

(1)static修饰成员函数

  该成员函数没有了this指针,只操作static变量,与对象没有关系

(2)const修饰成员函数

  表示该函数不会修改对象的数据(通过const this *)

(3)不能用static和const同是修饰成员函数

  因为static函数没有this指针,所以同时用两个修饰没有意义,编译器也会报错

-----

  数据成员初始化顺序:

    列表初始化方式:与定义成员变量的顺序有关

    const成员变量必须在构造函数初始化列表中初始化

    类的static成员变量,只能在类外初始化

  基类、派生类成员变量初始化:

    基类静态变量、全局变量

    派生类静态变量、全局变量

    基类成员变量

    派生类成员变量

 

 

 

6. 指针和引用

(1)

  指针是一个新的变量,存储另一个变量的地址。是间接操作另一个变量

  引用不是变量,只是一个别名,对引用的操作是直接操作在该引用关联的变量上

(2)

  就指针而言,有指向常量的指针 int const *p ,有指向不可变的指针常量 int *const p

  引用只有指向常量的引用 int const &a=b    而引用的指向本来就不可变

(3)

  指针有多级指针,引用只有一级

  指针可不初始化,引用必须初始化

  sizeof指针,得到指针变量所占空间,一般4字节  sizeof引用,得到其指向变量/对象大小

  自增运算符运算意义不一样

 

7. 多态

  含义:一个接口,多种方法

  目的:接口重用【封装:模块化  继承:代码扩展】

(1)静态多态/早绑定

  函数重载:函数名一样,返回值、参数个数、类型不一样

  编译期间确定调用哪个

(2)动态多态/晚绑定

  通过虚函数实现

  运行时才确定调用哪个

  用基类指针调用虚函数,根据指针实际指向对象类型调用相应的函数

 

(3)虚函数表

  类有虚函数时,则类会有一张虚函数表(表的每一项是一个虚函数的地址)

  类的每个对象有一个指向虚函数表的虚指针(位于对象地址前面)

 

  派生类有兼容基类的虚函数表,如果重写了一个虚函数,则在其虚函数表里面对应位置的函数地址替换为重写的函数地址

 

 

8. new和malloc

  new是运算符;malloc是库函数(一个语言的编译器能控制运算符)

  new会调用构造函数,delete会调用析构函数;  malloc、free不会

  new返回具体类型的指针;malloc返回void *指针

  new可被重载;malloc不能

 

9. C++内存分区

  代码区:存放二进制代码

  字符串常量区

  全局和静态区:全局变量、静态变量存储

  堆区:malloc、new从这里申请空间

  栈区:存放局部变量

 

10. 常用容器

  vector:基于数组

  deque双端队列:类似数组加链表的组织形式,使用起来类似数组或队列

  list双向链表、forward_list单向链表

  array:固定大小数组

  string

 

  map、set:无重复、有序  基于红黑树(插入、删除效率高)

  multimap、multiset:可重复、有序  基于红黑树(插入、删除效率高)

  

  unordered_map、unordered_set:无重复、无序  基于哈希表(查找效率高)

  unordered_multimap、unordered_multiset:可重复、无序  基于哈希表(查找效率高)

 

11. 内存泄漏

  可能场景:

  忘记释放动态申请的内存空间

  基类析构未声明为virtual

  系统资源忘记释放

  解决:

  重载new、delete

  使用智能指针:shared_ptr、weak_ptr、unique_ptr

 

12. C++11新特性

(1)auto类型推导、decltype

  用auto类型变量接收很复杂的类型:

for(vector<int>::const_iterator itr=vec.cbegin();itr!=vec.cend();++itr)

for(auto itr=vec.cbegin();itr!=vec.cend();++itr)

  auto不能用于函数传参

 

  decltype为了解决auto只能对变量进行类型推导的不足出现的,可判断表达式的类型:

auto x=1;
auto y=2.01;
decltype(x+y) c;

 

 

(2)for循环

int a[5]={1,2,3,4,5};
for(int &x:a) {
    cout<<x<<endl;
}

 

(3)lambda函数

[捕捉列表] (参数) mutable -> 返回值类型 {函数体}

  捕捉列表能捕捉上下文中的变量供函数使用

  mutable:取消默认的lambda的const属性,使函数体内能修改变量(不影响外部得到变量)

(4)override、final关键字

  在某个应该被子类重写的函数后加上override,表明这个函数是重写的虚函数

  在类名字后面加final或在函数后面加final,表明这个类不希望被继承,不希望这个函数被重写

(5)智能指针

  将基本类型指针封装为类对象指针,并在其析构函数里编写delete语句删除指针指向的内存空间  

(6)右值引用

  例子: 

string x = "abc";
string y = "def";
string a(x);
string b(x+y);
string c(fun()); //fun函数返回一个字符串

  第三行用x初始化a,则会调用相应的拷贝构造函数,进行深度拷贝

  第四行用x+y初始化b,实际上创建了一个临时变量,然后用这个临时变量初始化b,但是这个临时变量随机就丢弃了

  第五行用一个返回非引用类型的函数的返回值初始化c,也是用一个临时对象接收返回值,然后初始化c

 

  上面x是左值

  第四和第五行的参数是右值,表达式产生了string的匿名对象/临时对象,然后用临时对象初始化,然后丢弃临时对象,这样实际上多做了操作,通过右值引用简化流程。如下:修改构造函数,入参为右值引用

string (string && tmp)
{
    浅拷贝
}

  通过浅拷贝,将临时对象的地址复制给b或者c,然后将临时对象指针置空,充分利用了这个临时对象,这个构造函数也叫  "转移构造函数"

 

(7)空指针nullptr

  C中空指针常量NULL宏定义为0或 (void *)0,任意类型指针都可转换为 void *类型

  C++中别的类型指针不能与void *类型指针转换,且NULL宏定义为 0

 

  C++中0有了两个含义:整型数值0和NULL为了避免重载函数调用时二义性,定义了nullptr表示空指针来替代NULL

  

(8)线程支持

 

(9)构造函数

  委托构造:可在一个构造函数后调用另一个重载的构造

(10)新增容器

  ①std::array

  保存在栈中,编译时创建固定大小的数组

array<int,4> a={1,2,3,4};

int len=4;
array<int,len> b={1,2,3,4};  //错误,编译期间需要能确定大小

 

  不能隐式转换为指针:

void fun(int *p,int n)
{
    for(int i=0;i<n;i++) {
        cout<<*(p+i)<<endl;
    }
}

array<int,4> a={1,2,3,4};
fun(a,4); //错误,a不能被隐式转换为指针 fun(
&a[0],4); fun(a.data(),4);

 

  ②单向链表 forward_list

  ③无序容器四个  

  ④元组tuple

  固定大小的不同类型元素的集合

 

(11)正则表达式

string src[]={"aa.txt","a2.txt","123.txt","a334g.jpg"};
regex re(".*[0-9]\\.txt");//以数字结尾的txt
for(auto &x:src) {
    cout<<x<<":"<<regex_match(x,re)<<endl;
}

  技术图片

 

 

(12)其他

  .....

  

13. const和define

(1)起作用时间不同

  define在预处理阶段起作用,进行替换

  const在编译阶段起作用

(2)类型检查

  define不进行类型安全检查

  const有数据类型,编译时进行类型检查

(3)内存空间

  define不分配内存

  const需要在静态存储区中分配空间

 

14. 悬空指针和野指针

  悬空指针:所指向对象被释放,但指针变量的值未赋值空

  野指针:没有初始化的指针变量,值不确定

 

15. sizeof和strlen

(1)功能

  sizeof是运算符,用来计算一种类型所占内存大小

  strlen是函数,参数为char *,计算以‘\0‘结尾字符串的长度,且不包括‘\0‘

(2)只有用字符数组比较这两个才有意义

char a[]="abc";
sizeof(a);  //4
strlen(a); //3

 

 

16. 字节对齐

(1)结构体

  比如int为4字节的情况下,一般是4字节对其

(2)联合体

  联合体所占空间与最宽成员及其他成员都有关系:①大小足够容纳最宽的成员  ②大小能被其所有成员基本类型的大小整除

union u1{
    int n;
    char a[11];
    double b;
};

union u2{
    int n;
    char a[5];
    double b;
};

  u1类型需要空间16字节

  u2类型只要8字节

 

17. 类型转换

(1)

 

 

18. 计算类大小

  class A{};    sizeof(A)==1

  class A{virtual Fun(){}}  sizeof(A)==4(32位)   8(64位)

  class A{static int a;};  sizeof(A)==1

  class A{int a;};   sizeof(A)==4

  class A{static void fun(){}};  sizeof(A)==1

  类中static声明的成员变量不计算类的大小中

 

19. 大小端

  大端big endian:低地址存放高位字节

  小端little endian:第地址存放低位字节

 

  数0x12 34 56 78在内存中存放形式为:地址从左到右变大

    大端:0x12 0x34 0x56 0x78

    小端:0x78 0x56 0x34 0x12

 

20. C++中 * 和 & 同时使用

void fun(Node * &p);

  参数是一个Node类型指针的引用,在函数里面,不仅可通过p的值改变其指向的内容,也可以改变实参的值

  举例:一个单链表反转,head指针指向第一个结点,反转后需要其指向原链表最后一个结点

  ①通过指针的指针实现

Node * fun(Node **head)
{
    if(NULL == *head || NULL==(*head)->next) {
        return *head;
    }
    Node *p1 = *head;
    Node *p2 = p1->next;
    Node *p3 = NULL;
    (*head)->next = NULL;
    while(p2 != NULL) {
        p3 = p2->next;
        p2->next = p1;
        p1 = p2;
        p2 = p3;
    }
    *head = p1; //修改实参的值
    return p1; //或者返回该值  
}

Node *head = initList();
head = fun(&head); //通过传入指针的地址改变了实参head的值
                             //现在head是指向新的头结点,,即原链表的最后一个结点

 

  ②传入指针的引用

void fun(Node *&head)
{
    if(NULL==head || NULL == head->next) {
        return;
    }
    Node *p1 = head;
    Node *p2 = p1->next;
    Node *p3 = NULL;
    head->next = NULL;
    while(p2!=NULL) {
        p3 = p2->next;
        p2->next = p1;
        p1 = p2;
        p2 = p3;
    }
    head = p1;
}

Node *head = initList();
fun(head);

 

 

21. C++中堆和栈比较

(1)数据结构中的堆结构和栈结构

  栈:先进后出的结构

  堆:有大根堆和小根堆。大根堆是根结点值最大,且根结点的两个子树也是堆。用来实现优先队列,保证队列最前面的数是最大或最小的,每次取走一个数,堆调整结构,使得最前面的依然是最大或最小的

(2)内存分配中的栈和堆

  这里的堆不是数据结构中说的堆

  ①增长方向

    栈向下(向较低地址)增长;堆向上(向较高地址)增长

  ②申请方式

    栈由编译器自动管理;堆需要编写程序的人主动申请

  ③效率

    栈分配较快;堆申请较慢

  ④大小限制

    栈能获得的空间较小,且是连续的内存区域;堆能获得的空间较多,且不连续(链表管理)  

 

22. 空类

  编译器为空类自动生成 默认无参构造函数、默认拷贝构造函数、默认拷贝赋值运算符、默认析构函数

class A{};

class A{
public:
    A();
    A(const A&);
    ~A();
    A& operator=(const A&); 
};

 

23. 不能写成虚函数的函数

(1)普通函数

  非成员函数的普通函数只能重载

(2)友元函数

  友元函数不属于类的成员函数,不能被继承,不能写成虚函数

(3)构造函数

  构造函数用来初始化对象里面的成员,而基类构造不知道派生类有哪些成员

(4)内联成员函数

  内联函数在编译时展开,而虚函数在运行时绑定

(5)静态成员函数

  编译时确定,无法动态绑定,不支持多态

 

 

24. 一个string类的简答实现

class string{
public:
    string(const char* str);
    string(cosnt string &other);
    ~string();
    string & operator=(const string &other);
private:
    char *data;
};

//***********************//
string::string(const char *str) { if(NULL == str) { data = new char[1]; *data = \0; } else { int len = strlen(str); data = new char[len+1]; strcpy(data,str); } } string::string(const string &other) { int len = strlen(other.data); data = new char[len+1]; strcpy(data,other.data); } string::~string(){ delete [] data; } string::string& operator=(const string &other) { if(this==&other) { return *this; } delete [] data; int len = strlen(other.data); data = new char[len+1]; strcpy(data,other.data); return *this; }

 

25.分配内存的方法

(1)malloc

  void *malloc(unsigned int size)

  申请分配长度size字节的连续空间,空间内容没有初始化

(2)calloc

  void *calloc(unsigned int num,unsigned int size)

  申请分配num*size字节的空间,并初始化内存空间为0

(3)realloc

  void *realloc(void *ptr,unsigned int size)

  申请分配size字节空间,并把内存空间首地址赋值给ptr,不会初始化

(4)new

  申请分配空间,调用构造函数实现初始化

 

26. vector中直接访问和at访问

  vec[i]可能有越界风险  vec.at(i)会抛出异常

 

C++msbs

标签:临时对象   复制   set   deque   img   属性   表示   iterator   rtu   

原文地址:https://www.cnblogs.com/taoXiang/p/12796556.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!