学习参数传递及const成员变量初始化

该说的都在代码及注释中。

 

练习代码：

  1 #include <stdlib.h>
  2 #include <memory.h>
  3 
  4 /**
  5 * @author:zanzan101
  6 */
  7 
  8 // 这里的参数声明时：
  9 // int** arr 调用时错误！
 10 // int arr[][] 声明时错误！
 11 // int arr[][1] 调用时错误！
 12 // 唯一要求准确的条件是一维空间的长度，即需要知道列数，不需要知道行数，需要知道行的长度
 13 int sum_array(int arr[][5])
 14 {
 15     int sum = 0;
 16     for(int i = 0; i < 5; i ++)
 17         for(int j = 0; j < 5; j ++)
 18             sum += arr[i][j];
 19     return sum;
 20 }
 21 // 传指针的指针也可以传递二维数组过来
 22 int sum_array_2(int** arr, int m, int n)
 23 {
 24     int sum = 0;
 25     for(int i = 0; i < m; i ++)
 26         for(int j = 0; j < n; j++)
 27             sum += arr[i][j];
 28     return sum;
 29 }
 30 int sum_array_3(int* arr[5])
 31 {
 32     int sum = 0;
 33     for(int i = 0; i < 5; i ++)
 34         for(int j = 0; j < 5; j ++)
 35             sum += arr[i][j];
 36     return sum;
 37 }
 38 
 39 
 40 void func(int i)
 41 {
 42     printf("func_i\n");
 43 }
 44 void func(double d)
 45 {
 46     printf("func_d\n");
 47 }
 48 
 49 struct S1 
 50 {
 51     int v;
 52 };
 53 struct S2 
 54 {
 55     char c;
 56 };
 57 
 58 class A
 59 {
 60 private:
 61     static const int v;
 62     static int w;
 63 public:
 64     void func(S1)
 65     {
 66         printf("A v=%d\n", v);
 67     }
 68 };
 69 
 70 // 这是一种初始化static const类型的方式
 71 const int A::v = 2;
 72 // 这是一种初始化static的方式
 73 int A::w = 3;
 74 
 75 class B: public A
 76 {
 77 private:
 78     // 这是第二种初始化static const的方式
 79     static const int u = 2;
 80 
 81     // 这是错误的初始化方法
 82     // error C2864: “B::x”: 只有静态常量整型数据成员才可以在类中初始化
 83 //    static int x = 3;
 84 public:
 85 
 86     void func(S2)
 87     {
 88         printf("B1\n");
 89     }
 90     int func(S1, S2)
 91     {
 92         printf("B2\n");
 93         return 1;
 94     }
 95 };
 96 
 97 int main()
 98 {
 99     int arr[5][5] = {0};
100     arr[3][1] = 9;
101     arr[2][0] = 1;
102     arr[4][4] = 10;
103     int sum = sum_array(arr);
104     printf("%d\n", sum);
105     int** arr_2 = new int*[5];
106     for(int i = 0; i < 5; i ++)
107     {
108         arr_2[i] = new int[5];
109         memset(arr_2[i], 0, 5*sizeof(int));
110     }
111     arr_2[3][1] = 9;
112     arr_2[2][0] = 1;
113     arr_2[4][4] = 10;
114 
115     // 感觉优于第一种方法,因为这里不需要在函数中限定维度
116     sum = sum_array_2(arr_2, 5, 5);
117     printf("%d\n", sum);
118 
119     // error C2664: “sum_array”: 不能将参数 1 从“int **”转换为“int [][5]”
120 //    sum = sum_array(arr_2);
121 //    printf("%d\n", sum);
122 
123     // 以下声明错误：
124     // error C2440: “初始化”: 无法从“int [5][5]”转换为“int **”
125 //    int** arr_3 = arr;
126 
127     // 以下方法错误：
128     // 因为arr_3不为空,但它所指向的指针为空,这里没有理解.
129     /*
130     int** arr_3 = (int**)arr;
131     sum = sum_array_2(arr_3, 5, 5);
132     printf("%d\n", sum);
133 
134     sum = sum_array_3(arr_3);
135     printf("%d\n", sum);
136     */
137 
138     func(1);
139     func(1.0);
140     A a;
141     a.func(S1());
142     B b;
143     // C++的类继承中，有以下特点：
144     // 当子类中没有与父类非虚函数重名的函数时：
145     // 可以调用父类的函数
146     // 当子类中有任何一个与父类非虚函数重名的函数时（不管返回值类型和参数类型及个数）：
147     // 父类中的函数失效，只能调用到子类中的该名称的函数
148     // 以下用法错误：
149     // 因为父类中的函数失效，只能调用子类中的名为func的函数：
150 //    b.func(S1());
151 
152     // 正确用法：
153     b.func(S2());
154     b.func(S1(), S2());
155 
156 
157     system("pause");
158 
159     return 0;
160 }

输出：

20
20
func_i
func_d
A v=2
B1
B2
请按任意键继续. . .

 

转载于:https://www.cnblogs.com/zanzan101/p/3373198.html