C++数组，指针，字符串，引用

4）char[]

char * a="string1";
char b[]="string2";

char * a="string1";
char b[]="string2";
gets(a); //试图将读入的字符串保存到a指向的区域，运行崩溃！ 
gets(b) //OK

解释： a指向的是一个字符串常量，即指向的内存区域只读；
b始终指向他所代表的数组在内存中的位置，始终可写！

注意，若改成这样gets(a)就合法了：

char * a="string1";
char b[]="string2";
a=b; //a,b指向同一个区域
gets(a) //OK
printf("%s",b) //会出现gets(a)时输入的结果

解释： a的值变成了是字符数组首地址，即&b[0]，该地址指向的区域是char *或者说 char[8]，习惯上称该类型为字符数组，其实也可以称之为“字符串变量”，区域可读可写。

总结：char *本身是一个字符指针变量，但是它既可以指向字符串常量，又可以指向字符串变量，指向的类型决定了对应的字符串能不能改变！

char *a="Hello World"; 
char b[]="Hello World"; 
printf("%s, %d\n","Hello World", "Hello World"); 
printf("%s, %d %d\n", a, a,  &a);                           
printf("%s, %d %d\n", b, b,  &b);

Hello World，13457308
Hello World，13457308    2030316
Hello World，2030316 2030316

char * a=”string1”;是实现了3个操作：

1. 声明一个char*变量(也就是声明了一个指向char的指针变量);
2. 在内存中的文字常量区中开辟了一个空间存储字符串常量”string1”
3. 返回这个区域的地址，作为值，赋给这个字符指针变量a

const char * a="string1";

void fun1 ( char *p1,  char p2[] ) {
 printf("%s %d %d\n",p1,p1,&p1);
 printf("%s %d %d\n",p2,p2,&p2);
p2="asdf"; //通过! 说明p2不是常量！ 
printf("%s %d %d\n",p2,p2,&p2);
}
void main(）{
char a[]="Hello";
fun1(a,a);
}

Hello 3471628 3471332
Hello 3471628 3471336
asdf 10704764 3471336

void func(int **array);

template< 
    class T, 
    std::size_t N 
> struct array;

int n1 = arr1[0];
int n2 = arr1.at(0); 

int n3 = arr2d[0][0];

for(size_t i = 0; i < arr2d.size(); ++i)
{
	for(size_t j= 0; j < arr2d[i].size(); ++j)
	{
		cout << arr2d[i][j] << '\t';
	}
	cout << endl;
}

#include <iostream>
#include <array>

using namespace std;

int main()
{
    array<int, 10> arr = {17, 68, 87, 48, 1, 76, 90, 73, 95, 13};

    int minVal = INT_MAX;
    int maxVal = INT_MIN;
    int sum = 0;

    cout << "数组的元素：";

    for (int elem : arr)
    {
        cout << elem << ' ';

        minVal = minVal < elem ? minVal : elem;
        maxVal = maxVal > elem ? maxVal : elem;
        sum += elem;
    }

    cout << endl
        << "最大值：" << maxVal << endl
        << "最小值：" << minVal << endl
        << "平均值：" << double(sum) / arr.size() << endl;

    return 0;
}

数组的元素：17 68 87 48 1 76 90 73 95 13
最大值：95
最小值：1
平均值：56.8

 1 #include <iostream>
 2 
 3 using namespace std;  
 4 
 5 int main()
 6 {
 7     int rats = 101;
 8     int & rodents = rats;  //声明并初始化一个引用rodents，使rodents成为rats的别名
 9 
10     cout << "value of rats is: " << rats << "; " << "Address of rats is: " << &rats << endl;
11     cout << "value of rodents is: " << rodents << "; " << "Address of rodents is: " << &rodents << endl;
12 
13     int business = 50;
14     rodents = business;  //等价于rats = business,执行完此句之后，rats和rodents的值都会改变为50,且二者的地址相同,但二者的地址和business是不一样的
15     cout << "value of business is: " << business << "; " << "Address of business is: " << &business << endl;
16     cout << "value of rats is: " << rats << "; " << "Address of rats is: " << &rats << endl;
17     cout << "value of rodents is: " << rodents << "; " << "Address of rodents is: " << &rodents << endl;
18 
19     system("pause");
20     return 0;
21 }

1 //使用引用变量、指针、和普通变量作为函数参数交换形参的值
 2 #include <iostream>
 3 
 4 void swapr(int & a, int & b);  //声明参数为引用变量的函数
 5 void swapp(int* a, int* b);  //声明参数为指针的函数
 6 void swapv(int a, int b);  //声明参数为普通变量的函数
 7 
 8 int main()
 9 {
10     using namespace std;
11 
12     int wallet1 = 200;
13     int wallet2 = 300;
14 
15     cout << "原始数据为：wallet1 = " << wallet1 << endl;
16     cout << "原始数据为：wallet2 = " << wallet2 << endl;
17 
18     swapr(wallet1, wallet2);  //调用参数为引用变量的函数
19     cout << "调用参数为引用变量的函数：wallet1 = " << wallet1 << endl;
20     cout << "调用参数为引用变量的函数：wallet2 = " << wallet2 << endl;
21 
22     swapp(&wallet1, &wallet2);  //调用参数为指针的函数
23     cout << "调用参数为指针的函数：wallet1 = " << wallet1 << endl;
24     cout << "调用参数为指针的函数：wallet2 = " << wallet2 << endl;
25 
26     swapv(wallet1, wallet2);  //调用参数为普通变量的函数
27     cout << "调用参数为普通变量的函数：wallet1 = " << wallet1 << endl;
28     cout << "调用参数为普通变量的函数：wallet2 = " << wallet2 << endl;
29 
30     system("pause");
31     return 0;
32 }
33 
34 void swapr(int & a, int & b)  //该子函数修改的是主函数中的值，假如在主函数中调用该子函数时候传入了主函数中的值
35 {
36     int temp = a;
37     a = b;
38     b = temp;
39 }
40 void swapp(int* a, int* b)  ////该子函数修改的是主函数中的值，假如在主函数中调用该子函数时候传入了主函数中的值
41 {
42     int temp = *a;
43     *a = *b;
44     *b = temp;
45 }
46 void swapv(int a, int b)  //该子函数只是复制了传入该子函数的值给a、b,并交换了a和b的值，并没有交换主函数中的wallet1和wallet2的值
47 {
48     int temp = a;
49     a = b;
50     b = temp;
51 }

 1 #include <iostream>
 2 
 3 double cube(double a);  //声明一个普通函数
 4 double refcube(double &ra);  //声明一个形参为引用的函数
 5 
 6 int main()
 7 {
 8     using namespace std;
 9     
10     double x = 3.0;  //定义常规变量
11 
12     cout << cube(x) << " = cube of " << x << endl;  //调用普通函数，此时x的值不会改变
13 
14     cout << refcube(x) << " = cube of " << x << endl;  //但是这样将refcube(x)和x一起打印的话还是x的值是不变的，执行完这一句之后x = ra的值即27
15 
16     double z = refcube(x);  //调用引用函数,此时x的值会随着子函数中ra的值的改变而改变 此时x=27
17     cout <<z<< " = cube of " << x << endl;  //打印19683= cube of 19683
18 
19     /*如果ra是一个变量的别名(即引用),则实参应该是变量,而不应该是表达式*/
20     //double z1 = refcube(x+10);  //不合法
21     //double z1 = refcube(10);  //不合法
22     double yo[3] = { 2.2,3.3,4.5 };  //声明一个数组
23 
24     double z1 = refcube(yo[2]);  //合法  数组元素
25     cout << "refcube(yo[2]) = " << z1 << endl;
26 
27     /* 有关左值的概念 */
28     double side = 3.0;
29     double* pd = &side;  //创建指向side的指针pd
30     double & rd = side;  //创建引用变量,rd即等价于side
31     long edge = 5L;  //创建长型变量，注意要在数字最后加上字母L
32     double lens[4] = { 2.0,5.0,10.0,12.0 };  //创建数组
33 
34     double c1 = refcube(side);  //ra is side
35     double c2 = refcube(lens[2]);  //ra is lens[2]
36     double c3 = refcube(rd);  //ra is rd is side
37     double c4 = refcube(*pd); //ra is *pd is side
38 
39     double c5 = refcube(edge);  //不合法，因为ra是double类型的，而edge是long类型的
40     double c6 = refcube(7.0); //7.0是非左值，不合法
41     double c7 = refcube(side + 7.0);  //side+7.0是包含多项式的表达式，是非左值，不合法
42     //c++遇到上述三种类型,就会创建类型正确的匿名变量，将函数调用的参数的值传递给改匿名变量，并让参数来引用改变量
43 
44     
45 
46     system("pause");
47     return 0;
48 }
49 
50 double cube(double a)
51 {
52     /*a = a * a*a;*/
53     a = a*a * a;
54 
55     return a;
56 }
57 double refcube(double &ra)
58 {
59     //ra = ra * ra*ra;
60     ra = ra* ra * ra;  //也可以这么写  ra *= ra*ra;
61 
62     return ra;
63 }

 1 #include <iostream>
 2 #include <string>
 3 
 4 
 5 struct free_throws
 6 {
 7     std::string name;  //新建一个string型字符串变量name
 8     int  made;
 9     int attemps;
10     float percent;
11 };
12 
13 void display(const free_throws & ft);  //声明一个函数,形参为指向结构free_throws的引用ft,但是不可以通过ft来改变结构中的值,此处的ft为const引用参数
14 void set_pc(free_throws & ft); //声明一个函数,形参为指向结构free_throws的引用ft
15 free_throws & accumulate(free_throws & target, const free_throws & source);  //声明一个返回值为free_throws结构引用的函数accumulate,形参为两个指向结构的引用
16 
17 int main()
18 {
19     //初始化结构变量
20     free_throws one = { "Ifelsa Branch",13,14 }; //没有被赋值的就默认为0,比如以下均没有对percent赋值,则percent均为0
21     free_throws two = { "Andor Knott",10,16 };
22     free_throws three = { "Mininie Max",7,9 };
23     free_throws four = { "Whily Looper",5,9 };
24     free_throws five = { "Long Long ago",6,14 };
25     free_throws team = { "Throwgoods",0,0 };
26     free_throws dup;  //定义结构dup，没有初始化
27 
28     //01简单调用形参结构的子函数
29     set_pc(one);  //调用子函数，参数为指向结构的引用  此句为填充one结构中percent的值
30     display(one);  //调用子函数，参数为指向结构的引用  此句为显示整个one结构中的值
31 
32 
33     //02调用返回值为结构的子函数，但是这个返回值并没有使用，而是用子函数中的引用去修改主函数中结构的值
34     accumulate(team, one);  //这一句的确是会返回一个结构,但是由于该函数的形参为引用，所以传入的team结构中的值也会被改变
35     //其中在accumulate子函数中,第二个引用为conts类型,对应one,只是 用以下one结构中的值，不会改变one中的值，如果在子函数中要求改变，会报错
36     //在accumulate子函数中，第二个参数为非const类型，故可以在子函数中更改team中的值，且在子函数中修改target的值就是修改team的值

37     display(team);
38 
39     //03使用accumulate子函数的返回值，作为另外一子函数display的实参，accumulate子函数的返回值为引用，进一步说是结构引用
40     display(accumulate(team, two));              //使用accumulate(team, two)的返回值(team)作为display的实参
41     accumulate(accumulate(team, three),four);
42     display(team);
43 
44     //04将返回值赋给一个没有初始化的结构 dup
45     dup = accumulate(team, five);
46     std::cout << "display(team): \n";
47     display(team);
48 
49     std::cout <<"Displaying dup after assignment: '\n'";
50     display(dup);
51 
52     set_pc(four);  //重新设置结构four中的percent的值
53 
54     system("pause");
55     return 0;
56 }
57 
58 void display(const free_throws & ft)
59 {
60     using std::cout;
61     cout << "Name: " << ft.name << '\n';        //其中'\n'表示换行，用endl也是可以的
62     cout << " Made: " << ft.made << '\t';
63     cout << "Attemps: " << ft.attemps << '\t';  //'\t'表示制表符
64     cout << "Percent: " << ft.percent << '\n';
65 
66 }
67 void set_pc(free_throws & ft)  //由于没有对ft加限定符const,所以该子函数允许修改原结构中的变量的值
68 {
69     if (ft.attemps != 0)
70         ft.percent = 100.0f*float(ft.made) / float(ft.attemps);      //100.0f表示100为float型
71     else
72         ft.percent = 0;        //percent的值就被修改，而不用返回percent的值到主函数，是直接修改的主函数中的结构原型中的结构参数，而不是修改的副本
73 }
74 free_throws & accumulate(free_throws & target, const free_throws & source)
75 {
76     target.attemps += source.attemps;      //赋值操作
77     target.made += source.made;       //赋值操作
78     set_pc(target);          //在子函数中调用子函数，重新对指向结构的引用target赋值
79     return target;        //返回值为结构引用 或者说返回值为target,假如传入的是team，那么target就是team的引用,即target和team是等价的，返回target就是返回team了
80 }

String str = null;// null can be assigned to String
Integer itr = null;// you can assign null to Integer also
Double dbl = null; // null can also be assigned to Double
 
String myStr = (String) null;// null can be type cast to String
Integer myItr = (Integer) null;// it can also be type casted to Integer
Double myDbl = (Double) null;// yes it's possible, no erro

public class Why {
  public static void test() {
        System.out.println("Passed");
  }

  public static void main(String[] args) {
        Why NULL = null;
        NULL.test();
  }
}

hy aNull = null; 
aNull.test(); // 实际开发中不要这样写
// 调用 Why.test(), 不会抛出 NullPointerException

class T {
    public static void p() {
        System.out.println("p() in T");
    }
}

class T1 extends T {
    public static void p() {
        System.out.println("p() in T1");
    }
}

 
public class Main {
    public static void main(String[] args) {
        T t = new T1();
        t.p();
    }
}