标签：转换 secure system 返回 环境 const color efi 隐式
关于指针的引用，这里加入一段代码，帮助理解：
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 }
在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 }
struct就是一个public权限下的class。
有三种情况会调用拷贝构造函数：
我们知道，直接将一个对象赋值给另一个对象，这样的拷贝就是浅拷贝。如果被拷贝的对象里面只有基本的数据类型，那么这样的拷贝无非就是数据的相互赋值，完全没有问题。但是如果类中含有指针变量，指针变量在定义的时候是需要指向一段地址的，也就是说需要从堆中拿出一块内存，那么在这个指针进行拷贝的时候，会把这个指向的内存空间也进行拷贝；在堆中获取了空间以后，是需要释放的，那么在两个对象都被释放的时候，同一段内存就被释放了两次。这样就是违法的，会导致程序执行的崩溃，这也就是浅拷贝的弊端所在。
下面的例子就是浅拷贝：
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 }
explicit主要是防止隐式转换。
标签：转换 secure system 返回 环境 const color efi 隐式
原文地址：https://www.cnblogs.com/lzy820260594/p/11557329.html
