不是从零开始的c++学习笔记（002）——c++中的数据类型，函数重载

zzxwbs

1.结构体
1.1和c的相同点
语法上和c没有什么区别

1.2和c的不同点

1.2.1表达类型时，可以省略关键字struct
1.2.2没有任何成员变量的结构体大小是1，C语言中是0

1. #include <iostream>
   
2. using namespace std;
   
3. struct Fishcuser
   
4. {
   
5.        
   
6. };
   
7. int main()
   
8. {
   
9.         cout <<sizeof(Fishcuser) << endl;//1
   
10.         Fishcuser user;
    
11.         cout << sizeof user << endl;//1
    
12. }
    

复制代码

1.2.3结构体中可以定义函数（成员函数）
在结构体成员函数中可以直接访问该结构体的成员函数，无需通过“.”或者“->”，例如

1. #include <iostream>
   
2. using namespace std;
   
3. struct Fishcuser
   
4. {
   
5.         char name[256];
   
6.         int age;
   
7.         void show()
   
8.         {
   
9.                 cout << "我是" << name << "今年" << age << "岁" << endl;
   
10.         }
    
11. };
    
12. int main()
    
13. {
    
14.         Fishcuser user = {"beiai",22};
    
15.         Fishcuser *puser = &user;
    
16.         user.show();
    
17.         puser->show();
    
18. }
    

复制代码

2.联合体

2.1和c的相同点
语法上和c没有什么不同

2.2和c的不同点

2.2.1表达类型时，可以省略关键字union
2.2.2支持匿名联合，例如

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. 
   
5. int main()
   
6. {
   
7.         union
   
8.         {
   
9.                 int n;
   
10.                 char c[sizeof(n)];
    
11.         };
    
12.         n = 0x12345678;
    
13.         for(size_t i = 0;i <sizeof(c);i++)
    
14.         {
    
15.                 printf("%#x ",c[i]);//0x78 0x56 0x34 0x12字节序问题
    
16.         }
    
17. }
    

复制代码

3.枚举

3.1和c的相同点
语法上和c基本没什么不同

3.2和c的不同点

3.2.1表达类型时，可以省略关键字
3.2.2一个枚举变量，可以赋值给一个整数变量，一个整数变量，不能赋值给枚举变量，c++中的类型检查要比c要严格

4.bool类型
c++中天生就支持bool类型，不需要像C语言中那样需要导入stdbool头文件

1. #include <iostream>
   
2. int main(int argc, const char * argv[])
   
3. {
   
4.    
   
5.     bool b;
   
6.     b = true;
   
7.     b = false;
   
8.     std::cout << std::boolalpha << b << std::endl;
   
9.     std::cout << sizeof(bool) << std::endl;
   
10.    
    
11.     b = 5;
    
12.     b = 5.5;
    
13.     b = 'a';
    
14.     std::cout << std::boolalpha << b << std::endl;
    
15.    
    
16.     return 0;
    
17. }

复制代码

5.c++中的运算符转换（了解）
# ---- > %:
{        <%
&        bitand

6.c++中的函数和c函数的不同

6.1 c++中一个函数如果没有参数，则这个函数调用时严格匹配参数列表
void 类型的参数依然可用。void foo();相当于c语言中的void foo(void);

6.2不再支持c语言中的隐式声明
函数调用之前，必须进行生命或者定义

6.3不再像c函数，默认返回int类型
函数必须指定返回值类型，main函数例外

1. #include <iostream>
   
2. using namespace std;
   
3. void foo()
   
4. {
   
5.     cout << "foo()" << endl;
   
6. }
   
7. int  getmax(int x,int y);
   
8. //getmax(int x,int y);错误
   
9. int main()
   
10. {
    
11.     foo();
    
12.         //foo(1);错误
    
13.         //foo(1,2);错误
    
14.         cout << getmax(1,112) << endl;
    
15. }
    
16. int  getmax(int x,int y)
    
17. {   
    
18.     return  x>y?x:y;  
    
19. }
    
20. 
    

复制代码

7.函数重载

7.1概念
在同一作用域中，函数名相同，参数列表不同的函数构成重载关系，重载与返回类型无关，与参数名也无关，相同类型的引用与非引用不构成重载关系（关于引用可能会在下一期说明）

参数列表不同:参数的个数不同，参数的类型不同， 参数的顺序不同

调用函数时，根据实参与形参的类型匹配情况，选择一个确定的重载版本，这个过程叫做重载解析

只有同一作用域中的同名函数才涉及重载问题，不同作用域中的同名函数遵守名字隐藏原则

1. #include <iostream>
   
2. using namespace std;
   
3. int  getmax(int x,int y)
   
4. {
   
5.     cout << "getmax(int,int)" << endl;
   
6.         return x>y?x:y;
   
7. }
   
8. double getmax(int x,double y)
   
9. {
   
10.     cout << "getmax(int,double)" << endl;
    
11.         return x>y?x:y;
    
12. }
    
13. double getmax(double x,int y)
    
14. {
    
15.     cout << "getmax(double,int)" << endl;
    
16.         return x>y?x:y;
    
17. }
    
18. int main()
    
19. {
    
20.     getmax(1,2);
    
21.         getmax(1.5,2);
    
22.         getmax(1,2.0);
    
23.         // getmax(1.5,2.5);错误
    
24. }
    

复制代码

7.2使用函数指针调用重载的函数
函数指针会根据指针的类型，自动选择对相应的函数

1. #include <iostream>
   
2. using namespace std;
   
3. int  getmax(int x,int y)
   
4. {
   
5.     cout << "getmax(int,int)" << endl;
   
6.         return x>y?x:y;
   
7. }
   
8. double getmax(int x,double y)
   
9. {
   
10.     cout << "getmax(int,double)" << endl;
    
11.         return x>y?x:y;
    
12. }
    
13. double getmax(double x,int y)
    
14. {
    
15.     cout << "getmax(double,int)" << endl;
    
16.         return x>y?x:y;
    
17. }
    
18. int main()
    
19. {
    
20.     getmax(1,2);
    
21.         getmax(1.5,2);
    
22.         getmax(1,2.0);
    
23.         // getmax(1.5,2.5);
    
24.         /* 使用函数指针来调用 第二个函数 */
    
25.     double (*pfun) (int x,double y);
    
26.         pfun=getmax;
    
27.         pfun(1,1.5);
    
28.         double (*pfun2)(double x,int y);
    
29.         pfun2=getmax;
    
30.         pfun2(2.5,30);
    
31. }

复制代码

7.3重载的原理
c++ 语言底层在生成调用函数名时，不但要考虑函数，还要考虑参数列表，而c语言只考虑函数名。所以c++函数可以重载，而c语言函数不能。

重载是通过c++换名实现的，换名机制限制了c和c++模块之间的交叉引用

1. #include <iostream>
   
2. using namespace std;
   
3. /* 底层实现时函数真正的名字_Z6getmaxii */
   
4. int  getmax(int x,int y)
   
5. {
   
6.     return  x>y?x:y;
   
7. }
   
8. /* 底层实现时函数真正的名字_Z6getmaxid  */
   
9. double getmax(int x,double y)
   
10. {
    
11. 
    
12. }
    
13. int main()
    
14. {
    
15.     getmax(1,2);
    
16.         getmax(1,2.5);
    
17. }

复制代码

1. #include <stdio.h>
   
2. //C语言中底层实现时函数名就是getmax
   
3. int  getmax(int x,int y)
   
4. {
   
5.     return  x>y?x:y;
   
6. }
   
7. 
   
8. int main()
   
9. {
   
10.     getmax(1,2);
    
11. }
    

复制代码

7.4重载引入的问题，以及如何解决

7.4.1跨编译器调用会有问题
7.4.2使用extern "C" 指定函数按照c语言的方式来生成调用函数名

1. #include <iostream>
   
2. using namespace std;
   
3. /* 按照c语言的方式来生成调用函数名 */
   
4. // extern "C" int  getmax(int x,int y);
   
5. extern "C"
   
6. {
   
7.     int  getmax(int x,int y);       
   
8. }
   
9. int main()
   
10. {
    
11.     getmax(100,200);
    
12. }
    

复制代码

8.函数参数之哑元

8.1概念
如果一个函数的参数，只有参数类型，没有参数名，则这个参数称之为哑元

8.2作用

8.2.1让无参的参数列表严格匹配
8.2.2保持函数的向前兼容特性
例如加密解密算法函数中，新算法函数无需key参数，又需要和以前的函数兼容，可以使用哑元参数

1. const char* encode(const char* msg,int key);
   
2. const char* decode(const char* msg,int key);
   
3. 
   
4. const char* encode(const char* msg,int key);
   
5. const char* decode(const char* msg,int);

复制代码

8.2.3区分成员函数，以后会细说

1. #include <iostream>
   
2. using namespace std;
   
3. struct  Date
   
4. {
   
5.         /* 成员变量 */
   
6.     int  year;
   
7.         int  month;
   
8.         int  day;
   
9.         /* 默认前++ 需要使用 哑元区分后加加 */
   
10.     Date  operator++(){  }
    
11.         Date  operator++(int){  }
    
12. };
    
13. int main()
    
14. {
    
15.     Date  date={2015,7,7};
    
16.     ++date;
    
17.         date++;
    
18. }

复制代码

下期预告：函数参数的默认值，内联函数，c++中的动态内存分配，引用

xiaosanxian

挺好的，支持