C++总结体会

Posted lzy820260594

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++总结体会相关的知识,希望对你有一定的参考价值。

摘要:本文主要记录了在复习c++过程中的体会。

1、关于const

  1. 在c++中,const代表的是一种只读权限,即代表变量的值不可以再修改;
  2. 相比define而言,const修饰的数据可以有类型,更加地注重作用域;
  3. const修饰的变量用基础数据类型进行初始化时,只会标记到符号表,而不会分配内存;用变量名来进行初始化时,会分配内存;当const修饰的变量是一个自定义的数据类型时,那么也会分配内存;
  4. 只要进行了内存的分配,那么就可以通过指针的方式进行修改;
  5. 在c语言中const修饰的变量默认跨文件;而c++中的const修饰的变量默认作用于本文件,如果要实现跨文件,那么就应该借助extern;

2、关于typedef

  1. typedef可以用于给数据类型起别名:typedef  int  size,那么就可以用size来定义int型数据;
  2. typedef可以用于给某一个数组类型起别名:typedef  int   Arry[10],那么就可以用Arry来直接定义一个元素个数为10的int型的数组:Arry  buff=.......;
  3. typedef可以给一个指针类型起别名:typedef  int *  ptr,那么就可以直接用ptr来定义一个指针:ptr  p相当于int *  p;

3、关于引用reference

  1. 变量本质上就是某一个内存空间的代号,而引用本质上就是这个内存空间的代号2、代号3.......,所有的代号在本质上都一样,完全等价;
  2. 在定义一个变量时可以不对其进行初始化:int a;但是定义一个引用时则必须进行初始化:int  &b=a;这是因为既然起别名就要知道是为谁起别名,否则就没有意义,而被起别名的这段空间也必须是明确的才可以,正如我们给一个人起外号,必须要知道这个人是谁,我们不能说给某人起外号,给一个不知道的人起外号这都是没有意义的,所以引用不可以用于NULL;
  3. 对一个单一的变量建立引用是及其简单的,而给一个数组建立引用可以采用两种方式:第一种是借助typedef(typedef  int   Arry[10];Array &buff=arr;这里的arr是一个数组名);第二种是要将&buff括起来,表示数组名的引用(int (&buff)[10]=arr);
  4. 引用是通过指针常量来实现的(type  * const  ref=&val);这里的const是说明ref这个指针只可以指向val的空间,而不能指向其他的地址,这也就是为一个别名不能用于多个变量的实现原理;
  5. 对于指针的引用,在设置形参时,我们可以用二级指针的形式来表示  **p  ,也可以直接用引用来表示  *&p;
  6. 常量引用const  type &b=a;这里运用const的意思是不希望通过引用的方式将变量的值改变,多数应用在传参的过程中,不希望操作形参时将实参改变了;

关于指针的引用,这里加入一段代码,帮助理解:

 1 #include<iostream>
 2 
 3 using namespace std;
 4 
 5 struct Teacher
 6 
 7     int age;
 8 ;
 9 
10 void AgeChange(Teacher **teacher)  //这里的形参采用的是二级指针的方式
11     *teacher = new Teacher;    
12     (*teacher)->age = 10;
13 
14 void Age_Change(Teacher *&teacher)    //这里的形参就是一个引用
15     teacher->age = 100;
16 
17 
18 int main() 
19     Teacher *MrLiu=NULL;    //定义一个指针变量
20     
21     AgeChange(&MrLiu);   //根据形参要求,这里传入的是指针的地址
22     cout << (*MrLiu).age << endl;
23 
24     Age_Change(MrLiu);
25     cout << (*MrLiu).age << endl;
26 
27     delete MrLiu;
28     
29     system("pause");
30     return 0;
31 

4、关于extern"C"

在c++编译环境中,程序编译后,会发生函数的重载。而在c语言中并不会发生函数的重载,也就是说,当我们在c++环境中去调用c语言模块下的函数时,由于c++连接器会寻找重载后的函数,这当然是找不到的,那么此时就需要用到extern"C"。具体实现如下:

MyModule.h

 1 #ifndef MYMODULE_H
 2 #define MYMODULE_H
 3 
 4 #include<stdio.h>
 5 
 6 #if __cplusplus
 7 extern "C"
 8 #endif
 9 
10     void func1();
11     int func2(int a,int b);
12 
13 #if __cplusplus
14 
15 #endif
16 
17 #endif

MyModule.c

1 #include"MyModule.h"
2 
3 void func1()
4     printf("hello world!");
5 
6 int func2(int a, int b)
7     return a + b;
8 

TestExternC.cpp

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include<iostream>
 3 using namespace std;
 4 
 5 #if 0
 6 
 7     #ifdef __cplusplus
 8     extern "C" 
 9         #if 0
10             void func1();
11             int func2(int a, int b);
12         #else
13             #include"MyModule.h"
14         #endif
15     
16 
17     #endif
18 
19 #else
20 
21     extern "C" void func1();
22     extern "C" int func2(int a, int b);
23 
24 #endif
25 
26 int main()
27     func1();
28     cout << func2(10, 20) << endl;
29     return EXIT_SUCCESS;
30 

5、关于class和struct

struct就是一个public权限下的class。

6、关于拷贝构造函数

有三种情况会调用拷贝构造函数:

  1. 用旧对象初始化新对象;
  2. 函数的形参是普通的对象,进行值传递会调用拷贝构造函数;
  3. 函数的返回值是一个普通的对象;

7、关于构造函数的调用

  1. 如果在一个类中,用户不写任何一个构造函数,那么系统默认会提供无参构造函数、析构函数、拷贝构造函数;
  2. 如果在一个类中,用户写了拷贝构造函数,那么系统就不再提供任何一种构造函数;
  3. 如果在一个类中,用户写了非拷贝构造的构造函数,那么系统不会再提供无参构造函数,但是依然会提供默认构造函数;

8、关于深拷贝和浅拷贝

我们知道,直接将一个对象赋值给另一个对象,这样的拷贝就是浅拷贝。如果被拷贝的对象里面只有基本的数据类型,那么这样的拷贝无非就是数据的相互赋值,完全没有问题。但是如果类中含有指针变量,指针变量在定义的时候是需要指向一段地址的,也就是说需要从堆中拿出一块内存,那么在这个指针进行拷贝的时候,会把这个指向的内存空间也进行拷贝;在堆中获取了空间以后,是需要释放的,那么在两个对象都被释放的时候,同一段内存就被释放了两次。这样就是违法的,会导致程序执行的崩溃,这也就是浅拷贝的弊端所在。

下面的例子就是浅拷贝:

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 class Person 
 7 public:
 8     Person() 
 9     
10     Person(const char *name) 
11         m_name =(char*)malloc(strlen(name)+1);
12         strcpy(m_name,name);
13     
14     ~Person() 
15         if (m_name!=NULL)
16         
17             cout << "析构函数调用" << endl;
18             free(m_name);
19         
20     
21 private:
22     char *m_name;
23 ;
24 void test() 
25     Person p1("abc");
26     Person p2(p1);    //系统自带的默认拷贝构造函数,直接崩溃,属于浅拷贝
27 
28 
29 int main() 
30     test();
31 
32     system("pause");
33     return 0;
34 

 

而所谓深拷贝,就是要避免浅拷贝存在的弊端,为新的对象创建新的空间,然后再进行拷贝,这样就不会导致同一段内存被释放两次。具体如下:

 1 #define _CRT_SECURE_NO_WARNINGS
 2 #include <iostream>
 3 
 4 using namespace std;
 5 
 6 class Person 
 7 public:
 8     Person() 
 9     
10     Person(const char *name) 
11         m_name =(char*)malloc(strlen(name)+1);
12         strcpy(m_name,name);
13     
14     Person(const Person &person)    //自定义的拷贝构造函数
15         m_name = (char*)malloc(strlen(person.m_name)+1);
16         strcpy(m_name,person.m_name);
17     
18     ~Person() 
19         if (m_name!=NULL)
20         
21             cout << "析构函数调用" << endl;
22             free(m_name);
23         
24     
25 private:
26     char *m_name;
27 ;
28 void test() 
29     Person p1("abc");
30     Person p2(p1);    //拷贝构造函数
31 
32 
33 int main() 
34     test();
35 
36     system("pause");
37     return 0;
38 

9、关于explicit

explicit主要是防止隐式转换。

以上是关于C++总结体会的主要内容,如果未能解决你的问题,请参考以下文章

C++软件开发面试题总结

C++知识总结(内附超详细知识框架图)

C++知识总结(内附超详细知识框架图)

C++ json解决方案

关于java中函数参数传递的两种方式的总结

《Effective C++》阅读总结:让自己习惯C++