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

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

练习代码：

#include <stdlib.h>
#include <memory.h>

/**
* @author:zanzan101
*/

// 这里的参数声明时：
// int** arr 调用时错误！
// int arr[][] 声明时错误！
// int arr[][1] 调用时错误！
// 唯一要求准确的条件是一维空间的长度，即需要知道列数，不需要知道行数，需要知道行的长度
int sum_array(int arr[][5])
{
    int sum = 0;
    for(int i = 0; i < 5; i ++)
        for(int j = 0; j < 5; j ++)
            sum += arr[i][j];
    return sum;
}
// 传指针的指针也可以传递二维数组过来
int sum_array_2(int** arr, int m, int n)
{
    int sum = 0;
    for(int i = 0; i < m; i ++)
        for(int j = 0; j < n; j++)
            sum += arr[i][j];
    return sum;
}
int sum_array_3(int* arr[5])
{
    int sum = 0;
    for(int i = 0; i < 5; i ++)
        for(int j = 0; j < 5; j ++)
            sum += arr[i][j];
    return sum;
}


void func(int i)
{
    printf("func_i
");
}
void func(double d)
{
    printf("func_d
");
}

struct S1 
{
    int v;
};
struct S2 
{
    char c;
};

class A
{
private:
    static const int v;
    static int w;
public:
    void func(S1)
    {
        printf("A v=%d
", v);
    }
};

// 这是一种初始化static const类型的方式
const int A::v = 2;
// 这是一种初始化static的方式
int A::w = 3;

class B: public A
{
private:
    // 这是第二种初始化static const的方式
    static const int u = 2;

    // 这是错误的初始化方法
    // error C2864: “B::x”: 只有静态常量整型数据成员才可以在类中初始化
//    static int x = 3;
public:

    void func(S2)
    {
        printf("B1
");
    }
    int func(S1, S2)
    {
        printf("B2
");
        return 1;
    }
};

int main()
{
    int arr[5][5] = {0};
    arr[3][1] = 9;
    arr[2][0] = 1;
    arr[4][4] = 10;
    int sum = sum_array(arr);
    printf("%d
", sum);
    int** arr_2 = new int*[5];
    for(int i = 0; i < 5; i ++)
    {
        arr_2[i] = new int[5];
        memset(arr_2[i], 0, 5*sizeof(int));
    }
    arr_2[3][1] = 9;
    arr_2[2][0] = 1;
    arr_2[4][4] = 10;

    // 感觉优于第一种方法,因为这里不需要在函数中限定维度
    sum = sum_array_2(arr_2, 5, 5);
    printf("%d
", sum);

    // error C2664: “sum_array”: 不能将参数 1 从“int **”转换为“int [][5]”
//    sum = sum_array(arr_2);
//    printf("%d
", sum);

    // 以下声明错误：
    // error C2440: “初始化”: 无法从“int [5][5]”转换为“int **”
//    int** arr_3 = arr;

    // 以下方法错误：
    // 因为arr_3不为空,但它所指向的指针为空,这里没有理解.
    /*
    int** arr_3 = (int**)arr;
    sum = sum_array_2(arr_3, 5, 5);
    printf("%d
", sum);

    sum = sum_array_3(arr_3);
    printf("%d
", sum);
    */

    func(1);
    func(1.0);
    A a;
    a.func(S1());
    B b;
    // C++的类继承中，有以下特点：
    // 当子类中没有与父类非虚函数重名的函数时：
    // 可以调用父类的函数
    // 当子类中有任何一个与父类非虚函数重名的函数时（不管返回值类型和参数类型及个数）：
    // 父类中的函数失效，只能调用到子类中的该名称的函数
    // 以下用法错误：
    // 因为父类中的函数失效，只能调用子类中的名为func的函数：
//    b.func(S1());

    // 正确用法：
    b.func(S2());
    b.func(S1(), S2());


    system("pause");

    return 0;
}

输出：

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