17Q&A-Week2

三明二中高二（17）班。
（每天下午自习课后把各大未解之谜收集起来贴到后黑板神马的。。
唔……又抓到不少好题……

Q：求\(y=\sqrt{x^{2}-2x+2}+ \sqrt{x^{2}-4x+8}\)的最小值

A：\(y=\sqrt{(x-1)^{2}+1^{2}}+ \sqrt{(x-2)^{2}+2^{2}}\) 即X轴上的点到(1,1),(2,-2)的距离之和。

之后数形结合就不用说了吧

Q：电容器串联会怎么样？

A：
\[q_{1}=q_{2}=Q\]
\[U=U_{1}+U_{2}=Q/C_{1}+Q/C_{2} \]
\[1/C=1/C_{1}+1/C_{2}\]

Q：手机充电器放在插座上会耗电吗？

A:有，很小，主要是变压器空载损耗和控制电路的功率。但就那么几mW的……电表测的出来吗？

开关电源只要不是太差，太偷工减料，功率因数不会太低的，一般从0.8-0.99之间，取平均值0.9来看的话，这只充电器在240V输入待机状态下消耗 P=0.9*240V*0.000832A=0.18W 那么插一年的话也就消耗1.576KW左右，1.5度电，按照峰电电价最贵0.8一度计算，才1块多，算上峰谷的话，一年1块钱内。

[http://www.guokr.com/question/457294/]

Q：镀锌的时候如何控制[H+]不放电？

A:利用氰氢酸的电离度极小，用氰化物镀锌。如果产生了气泡，高温除氢即可。

PS:

本来氢离子的标准电极电位比锌要正一些，应该优先于锌离子析出。但析出时还要考虑到氢离子在该析出的材料上的超电位，这就使得锌离子的实际电位比氢的还要正，故是锌的析出而不是氢的析出。[http://zhidao.baidu.com/question/257096764.html]

17Q&A-Week1

三明二中高二（17）班。
（每天下午自习课后把各大未解之谜收集起来贴到后黑板神马的。。
第一天就碰到了很多奇葩的问题。选几个来看看。

Q：求证1 + 1 = 2

A：（前几天刚背过，复习一下。居然真有人问23333

定义自然数：

\(\mathbb{0}\)是自然数;

每一个确定的自然数a，都有一个确定的后继数a'，a'也是自然数.

如果自然数b c的后继数都是自然数a,那么b = c,

\(\mathbb{0}\)不是任何自然数的后继数;

任意关于自然数的命题,如果证明了它对自然数0是对的,又假定它对自然数 n为真时,可以证明它对n' 也真,那么,命题对所有自然数都真.

更正式的定义如下:
一个戴德金-皮亚诺结构为一满足下列条件的三元组(X, x, f):
X 是一集合,x 为 X 中一元素,f 是 X 到自身的映射。
x 不在 f 的值域内.（对应上面的公理4）
f 为一单射.（对应上面的公理3）
若 A 为 X 的子集并满足:
x \(\in\) A, 且
\(a \in A \rightarrow f(a) \in A\)
则 A = X。

定义加法:
我们定义，加法是满足以下两种规则的运算:
1. \(\forall m \in \mathbb{Z},0 + m = m\)
2. \(\forall m,n \in \mathbb{Z},n' + m = (n + m)'\);

以下证明1+1=2
1 + 1
　　= 0’ + 1 （根据自然数的公理）
　　= (0 + 1)’（根据加法定义 2）
　　= 1’ （根据加法定义 1）
　　= 2 （根据自然数的公理）

Q：已知x为男生，命题“若x是人，则x是男人”为真。可是该命题的逆否命题。。

A：也是真命题。
［ http://m.guokr.com/question/229866/ ］
p→q
1若：p是真，q是真，则 p\(\rightarrow\)q是真；
2若：p是真，q是假，则 p\(\rightarrow\)q是假；
3若：p是假，q是真，则 p\(\rightarrow\)q是真；
4若：p是假，q是假，则 p\(\rightarrow\)q是真。
假命题是任何命题的充分条件。
所以说如果太阳从西边出来了，那么我就是超人。

Q：高尔基体、生长素和抗原分别是什么？

生长素参见人教版生物必修三p46
抗原参见必修三p37和http://zh.wikipedia.org/wiki/抗原
高尔基体参见http://zh.wikipedia.org/wiki/高尔基体
高尔基体的作用就相当于一个物流车间。好比给组装好的车子安上轮胎，打上标签和车牌，运到目的地就可以开了。
更形式化的说法是蛋白质翻译后修饰的场所。

忽然感觉存在感高了好多

Status

按惯例翻了翻百度统计的数据，PV还是稳定在两位数。
搜索词稳定的每天一个Librazy。
等等访问来源有一个http://kurunie.duapp.com/
扫到duapp我的第一反应是brainpass，再一看不对啊
长按，访问网址，回车（opera mini确实不错。。
看了看他的博文。。我有那么值得膜拜吗。。
还有卡兜名片内个自我介绍很明显是抄袭我的风格啊。。
最大的怨念是为什么不用holodark主题了。。很明显他之前用过。。目测是这个主题的第一个使用者啊。
以上

C语言速成手册（四）：指针、动态内存分配、标准输入

Via http://www.matrix67.com/blog/article.asp?id=271 by Matrix67

目录：
C语言速成手册（一）：基本数据类型、标准输出、函数
 C语言速成手册（二）：布尔值、条件判断、循环
 C语言速成手册（三）：数组、字符串、结构
 C语言速成手册（四）：指针、动态内存分配、标准输入
 C语言速成手册（五）：其它运算符、文件操作、其它函数
 C语言速成手册（六）：其它问题、后记

指针的定义
定义一个指针的方法如下：

类型名 *指针名;

类型名 *指针名;

例如，下面的语句定义了一个指针：

int *pointer;

1	int *pointer;

这样，pointer就是一个指针，它指向的是一个int类型的数据。

一个指针可以是一个合法的内存地址，也可以为0（通常写成NULL）。
你可以用printf语句输出一个指针，对应的标识为"%p"。下面的代码可以输出上面定义的指针指向的地址。

printf("%p",p);

1	printf("%p",p);

取地址与引用
假如a是一个变量，p是一个指针，那么&a返回该变量的地址，*p返回该指针所指的内容（称做“引用”）。
阅读下面的代码片段：

int *p;
int a = 520;
p = &a;
printf( "%p -> %d\n", p, *p );
*p = 1314;
printf( "%p -> %d\n", p, *p );
printf( "a = %d", a );

int *p;

int a = 520;

p = &a;

printf( "%p -> %d\n", p, *p );

*p = 1314;

printf( "%p -> %d\n", p, *p );

printf( "a = %d", a );

程序输出如下。当执行了p=&a后，存取*p就相当于是存取变量a了。

0022FF78 -> 520
0022FF78 -> 1314
a = 1314

0022FF78 -> 520

0022FF78 -> 1314

a = 1314

动态内存分配
首先介绍sizeof函数（准确地说是一个运算符），它的参数为一个变量名或类型名，返回的是它所占内存空间的大小。下面的代码输出1 8 800 4 1 。

long long a;
double b[100];
_Bool *c;
printf( "%d " , sizeof(char) );
printf( "%d " , sizeof(a) );
printf( "%d " , sizeof(b) );
printf( "%d " , sizeof(c) );
printf( "%d " , sizeof(*c) );

long long a;

double b[100];

_Bool *c;

printf( "%d " , sizeof(char) );

printf( "%d " , sizeof(a) );

printf( "%d " , sizeof(b) );

printf( "%d " , sizeof(c) );

printf( "%d " , sizeof(*c) );

下面介绍四种动态内存分配函数，使用它们前需要在程序最前面包含头文件stdlib.h。四种函数的格式分别为：

void *malloc ( size );
void *calloc ( n, size );
void free ( pointer );
void *realloc( pointer, size );

void *malloc ( size );

void *calloc ( n, size );

void free ( pointer );

void *realloc( pointer, size );

    函数malloc将在内存里寻找一个大小为size的连续空间，把分配到的内存地址作为一个指向void类型的指针（默认的无类型指针）返回。如果空间分配失败，函数返回NULL。
    函数calloc将在内存里寻找一个大小为n * size的连续空间，并且把这段内存的数据全部清0，返回数据和malloc一样。如果空间分配失败，函数返回NULL。
    函数free用于释放内存空间，释放后的空间被回收，可以用于以后的malloc或calloc操作。
    函数realloc在保证已有数据不变的情况下改变已有指针的空间大小，返回重新分得的空间的内存地址（有可能和原来不同）。如果空间重新分配失败，函数返回NULL。
    Pascal中的new语句可以用前两个函数代替，free语句则相当于Pascal中的dispose。

注意，malloc和calloc函数所返回的指针还没确定类型，理论上需要用类型转换。下面的程序合法地为p指针分配空间：

int *p;
p = (int *) malloc( sizeof(int) );
*p = 520;

int *p;

p = (int *) malloc( sizeof(int) );

*p = 520;

事实上，由于赋值时C语言自动转换类型，因此那个类型转换是没有必要的（去掉(int *)没有影响）。

指针与结构
一个指针可以指向一个结构，一个结构也可以包含一个指针。结构里包含一个指向结构的指针就构成了链表：

struct node{
   int value;
   struct node *next;
}

struct node{

int value;

struct node *next;

}

这样，定义struct node *a，则(*a).next就是另一个指向node结构的指针。在C语言中，(*x).y的句型很常用，因此有一个专门的记号x->y来代替(*x).y这样繁杂的写法。
你可以从下面的程序中看到链表的使用。

#include <stdio.h>
#include <stdlib.h>
    
struct node
{
   int value;
   struct node *next;
};

int main()
{
    struct node *head = NULL;
    int i;

    for(i=1;i<=10;i=i+1)
    {        
        struct node *newNode;
        newNode = malloc( sizeof(struct node) );
        newNode->value = i;
        newNode->next = head;
        head = newNode;
    }
    
    struct node *p = head;
    while (p)
    {
        printf( "%d\n", p->value );
        p = p->next;
    }
    return 0;
}

#include <stdio.h>

#include <stdlib.h>

struct node

{

int value;

struct node *next;

};

int main()

{

struct node *head = NULL;

int i;

for(i=1;i<=10;i=i+1)

{

struct node *newNode;

newNode = malloc( sizeof(struct node) );

newNode->value = i;

newNode->next = head;

head = newNode;

}

struct node *p = head;

while (p)

{

printf( "%d\n", p->value );

p = p->next;

}

return 0;

}

指针与函数
前面说过，C语言中的函数参数和变量只能够供该函数使用。
下面四个程序代码的输出分别是什么？

代码一：

#include <stdio.h>
void swap( int a, int b )
{
   int c = a;
   a = b;
   b = c;
}
int main()
{
   int a = 520, b = 1314;
   swap( a , b );
   printf( "%d %d", a, b );
   return 0;
}

#include <stdio.h>

void swap( int a, int b )

{

int c = a;

a = b;

b = c;

}

int main()

{

int a = 520, b = 1314;

swap( a , b );

printf( "%d %d", a, b );

return 0;

}

代码二：

#include <stdio.h>
int a = 520, b = 1314;
void swap( int a, int b )
{
   int c = a;
   a = b;
   b = c;
}
int main()
{
   swap( a , b );
   printf( "%d %d", a, b );
   return 0;
}

#include <stdio.h>

int a = 520, b = 1314;

void swap( int a, int b )

{

int c = a;

a = b;

b = c;

}

int main()

{

swap( a , b );

printf( "%d %d", a, b );

return 0;

}

代码三：

#include <stdio.h>
int a = 520, b = 1314;
void swap()
{
   int c = a;
   a = b;
   b = c;
}
int main()
{
   swap();
   printf( "%d %d", a, b );
   return 0;
}

#include <stdio.h>

int a = 520, b = 1314;

void swap()

{

int c = a;

a = b;

b = c;

}

int main()

{

swap();

printf( "%d %d", a, b );

return 0;

}

代码四：

#include <stdio.h>
void swap( int *a, int *b )
{
   int c = *a;
   *a = *b;
   *b = c;
}
int main()
{
   int a = 520, b = 1314;
   swap( &a, &b);
   printf( "%d %d", a, b );
   return 0;
}

#include <stdio.h>

void swap( int *a, int *b )

{

int c = *a;

*a = *b;

*b = c;

}

int main()

{

int a = 520, b = 1314;

swap( &a, &b);

printf( "%d %d", a, b );

return 0;

}

    答案：前两个程序输出520 1314，后两个程序输出1314 520。
    前两个程序中，待交换的两个数（即使是全局变量）作为参数传给了swap函数，该函数里的操作对函数外无影响。
    第三个程序中，swap函数对全局变量直接进行操作，其影响是全局的。
    最后一个程序巧妙地应用了指针来实现两数交换。函数的参数是指针类型，这个函数不能改变指针本身，但可以改变指针所指的内容。这是写此类函数通常所用的方法。
    为了强调函数void swap( int *a, int *b )中的指针本身不发生改变，很多地方喜欢写成void swap(const int *a, const int *b ) 。

指针与数组
数组由内存的连续空间构成，因此可以用指针来访问。事实上，数组名本身就是一个指针。观察下列代码：

int a[100];
printf("%p\n", &a[0]);
printf("%p\n", a);
printf("%d\n", a == &a[0] );

printf("%p\n", &a[1]);
printf("%p\n", a+1);

int a[100];

printf("%p\n", &a[0]);

printf("%p\n", a);

printf("%d\n", a == &a[0] );

printf("%p\n", &a[1]);

printf("%p\n", a+1);

看看输出结果（自己运行），你会发现，数组名其实就是一个指向数组起始位置的指针，其作用相当于&a[0]。而指针本身可以进行加减运算（表示内存地址的加减，具体加多少减多少取决于指针所指的类型），其本质是在数组中进行定位。因此，下面的两个代码是完全等价的：

int i, a[100];
for ( i=0; i<100; i=i+1 ) *(a+i)=i;
int i, a[100];
for ( i=0; i<100; i=i+1 ) a[i]=i;

int i, a[100];

for ( i=0; i<100; i=i+1 ) *(a+i)=i;

int i, a[100];

for ( i=0; i<100; i=i+1 ) a[i]=i;

下面的程序输出0 1 2 3 4 0。函数init不能改变变量的值，但由于数组的实质是指针，因此它可以改变数组所储存的内容。

#include <stdio.h>
void init( int a[5], int b )
{
   int i;
   for ( i=0; i<5; i=i+1 ) a[i]=i;
   b = 5;
}
int main()
{
   int i, a[5], b=0;
   init( a, b );
   for ( i=0; i<5; i=i+1 ) printf("%d ",a[i]);
   printf( "%d\n", b );
   return 0;
}

#include <stdio.h>

void init( int a[5], int b )

{

int i;

for ( i=0; i<5; i=i+1 ) a[i]=i;

b = 5;

}

int main()

{

int i, a[5], b=0;

init( a, b );

for ( i=0; i<5; i=i+1 ) printf("%d ",a[i]);

printf( "%d\n", b );

return 0;

}

你甚至可以用指针来创建数组。使用函数calloc可以方便地得到指定长度并已全部初始化为0的数组。再加上realloc函数后，你就可以实现真正意义上的动态数组（长度可变）。示例程序如下：

#include <stdio.h>
#include <stdlib.h>
int main()
{
   int i, *a;
   a = calloc(sizeof(int),5);
   for ( i=0; i<5; i=i+1 ) *(a+i)=i;
   for ( i=0; i<5; i=i+1 ) printf("%d",a[i]);
   a = realloc(a,sizeof(int)*10);
   for ( i=5; i<10; i=i+1 ) a[i]=10-i;
   for ( i=0; i<10; i=i+1 ) printf("%d",a[i]);

   return 0;
}

#include <stdio.h>

#include <stdlib.h>

int main()

{

int i, *a;

a = calloc(sizeof(int),5);

for ( i=0; i<5; i=i+1 ) *(a+i)=i;

for ( i=0; i<5; i=i+1 ) printf("%d",a[i]);

a = realloc(a,sizeof(int)*10);

for ( i=5; i<10; i=i+1 ) a[i]=10-i;

for ( i=0; i<10; i=i+1 ) printf("%d",a[i]);

return 0;

}

上面的程序将输出012340123454321。

标准输入
    之所以现在才来说读入操作，是因为读入函数需要用到指针知识，否则解释不清楚。
    输入操作用scanf函数，和输出一样需要有stdio.h支持。
    和输出操作一样，scanf函数的第一个参数也是一个字符串，读入同样采用匹配标识符的方法进行。所不同的是，读入函数的参数是需要随函数变化的，因此变量作为scanf的参数时需要加上取地址符号，作为指针代入函数才行。除了读入%c类型之外，所有读入操作均自动跳过空格。
    看下面四个例子：

代码一：

int a, b;
scanf( "%d%d" , &a , &b );

1 2	int a, b; scanf( "%d%d" , &a , &b );

输入：
8 2
则a为8，b为2。

===========性感的分割线===========

代码二：

int a;
char b;
scanf( "%d%c" , &a , &b );

int a;

char b;

scanf( "%d%c" , &a , &b );

输入：
8 2
则a为8，b为一个空格。

===========性感的分割线===========

代码三：

int h, m, s;
scanf( "%d:%d:%d" , &h , &m, &s );

1 2	int h, m, s; scanf( "%d:%d:%d" , &h , &m, &s );

输入：
20:19:02
则h为20，m为19，s为2。

输入：
20:19-02
则h为20，m为19，s没有获得新的值（匹配失败）。

===========性感的分割线===========

代码四：

char st[80];
scanf( "My favourite website is%s" , st );

1 2	char st[80]; scanf( "My favourite website is%s" , st );

输入：
My favourite website is matrix67.com, I love it!
则st为"matrix67.com," 。

注意最后这个例子，st是数组，本质上是一个指针，因此不需要加&符号。

C语言速成手册（三）：数组、字符串、结构

Via http://www.matrix67.com/blog/archives/218 by Matrix67

一维数组的定义、初始化和使用
定义一个一维数组的格式如下：

类型 数组名[数组大小];

1	类型数组名[数组大小];

数组的下标范围总是从0开始（因此下标最大为数组大小减一）。下面一行语句定义了一个大小为10的长整型数组：

long value[10];

1	long value[10];

这相当于下面的Pascal语句：

var value:array[0..9]of longint;

1	var value:array[0..9]of longint;

C语言的数组范围左端点不能自定义，它的数组下标只能从0开始。

下面几种方式可以在定义数组的同时进行初始化：

long value[10] = { 0, 8, 2, 0, 3 } ;
long value[10] = { [1]=8, [2]=2, [4]=3 } ;

1 2	long value[10] = { 0, 8, 2, 0, 3 } ; long value[10] = { [1]=8, [2]=2, [4]=3 } ;

    上面两个语句是等价的。其中前一种方法依次对数组的前5个数进行初始赋值，后一种方法仅对数组的其中三个位置进行初始化。初始化中没有涉及到的下标所对应的数值自动被设为0。
    C语言允许数组的大小为一个变量，但这样的数组在定义时不能像上面一样进行初始化。
    这种初始化方法只在定义数组时用，不能用于程序中的赋值。数组之间也不能直接赋值，你不能把数组a整个赋值给数组b。

程序中使用数组的方法和Pascal一样。下面的程序将输出1000以内的素数：

#include <stdio.h>
#include <stdbool.h>
int main()
{
   bool isPrime[1000];
   int i,j;
   
   for(i=2;i<1000;i=i+1)
      isPrime[i]=true;
      
   for(i=2;i<1000;i=i+1)
   {
      if (isPrime[i])
      {
          printf("%d ",i);
          for(j=2*i;j<1000;j=j+i)
             isPrime[j]=false;   
      }
   }
   return 0;
}

#include <stdio.h>

#include <stdbool.h>

int main()

{

bool isPrime[1000];

int i,j;

for(i=2;i<1000;i=i+1)

isPrime[i]=true;

for(i=2;i<1000;i=i+1)

{

if (isPrime[i])

{

printf("%d ",i);

for(j=2*i;j<1000;j=j+i)

isPrime[j]=false;

}

return 0;

}

当一维数组作为函数参数时，数组大小可以不写，以适应不同长度的数组。通常你还需要另一个参数告诉函数你的数组有多大。下面这个函数返回数组中的最大值：

long maxValue ( long length, long array[] )
{
   long i, max = 0;
   for ( i=0; i&amp;lt;length; i=i+1)
      if (array[i]>max) max = array[i];
   return max;
}

long maxValue ( long length, long array[] )

{

long i, max = 0;

for ( i=0; i&lt;length; i=i+1)

if (array[i]>max) max = array[i];

return max;

}

下面的代码合法地调用了上面的函数。

long a[5] = { 1, 5, 7, 3, 4 };
printf( "%d" , maxValue( 5,a ) );

1 2	long a[5] = { 1, 5, 7, 3, 4 }; printf( "%d" , maxValue( 5,a ) );

C语言中的字符串
C语言也使用字符数组作为字符串。定义一个char a[20]，就相当于定义了一个长度不超过20的字符串。Pascal中使用a[0]记录字符串的长度，字符串内容从a[1]开始；但C语言并不直接记录字符串长度，a[0]表示字符串的第一个字符，最后以ASCII码0（或写成字符'\0'）标记字符串结尾。你可以直接将一个字符串赋给字符数组，也可以在printf中使用%s标识输出一个字符数组。记住，a[2]表示字符串中的第三个字符，因为C的数组下标是从0开始的。
观察下列代码：

int i;
char a[20]="matrix67.com";

for (i=0;i<20;i=i+1)
   printf("%d ",a[i]);
printf("\n%c\n",a[2]);
printf("%s\n",a);
printf("%16s\n",a);
printf("%.8s\n",a);
printf("%16.8s\n",a);

int i;

char a[20]="matrix67.com";

for (i=0;i<20;i=i+1)

printf("%d ",a[i]);

printf("\n%c\n",a[2]);

printf("%s\n",a);

printf("%16s\n",a);

printf("%.8s\n",a);

printf("%16.8s\n",a);

程序的输出为：

109 97 116 114 105 120 54 55 46 99 111 109 0 0 0 0 0 0 0 0
t
matrix67.com
    matrix67.com
matrix67
        matrix67

109 97 116 114 105 120 54 55 46 99 111 109 0 0 0 0 0 0 0 0

matrix67.com

matrix67

== 或 + 等运算符对字符串无效。

下面的函数返回字符串的字符数：

int stringLength( char a[] )
{
   int count=0;
   while ( a[count] )
      count=count+1;
   return count;
}

int stringLength( char a[] )

{

int count=0;

while ( a[count] )

count=count+1;

return count;

}

赋值时，如果字符串太长了，有两种方法可以让你分行写。一是在行末加一个反斜杠表示和下一行相连，二是每一行都用双引号注明（编译器会自动把它连接起来）。下面两个代码是等价的。注意第一个代码中的第二行必须顶格写，否则第二行前面的空格也要算进字符串里。

char blogTitle[100]="Matrix67: My Blog - 50% Informatics, 50% \
Mathematics, and 50% Imagination";
char blogTitle[100]="Matrix67: My Blog - 50% Informatics, 50% "
                 "Mathematics, and 50% Imagination";

char blogTitle[100]="Matrix67: My Blog - 50% Informatics, 50% \

Mathematics, and 50% Imagination";

char blogTitle[100]="Matrix67: My Blog - 50% Informatics, 50% "

"Mathematics, and 50% Imagination";

和数组一样，对字符串的赋值只能在定义时使用，程序中不能这样做。

多维数组的定义、初始化和使用
定义一个多维数组的格式如下：

类型 数组名[大小1][大小2]...[大小n];

1	类型数组名[大小1][大小2]...[大小n];

例如，下面这个语句定义了一个三维数组：

int matrix[100][100][2];

1	int matrix[100][100][2];

同样地，每一维的大小都是从0开始算的。因此上面的语句相当于Pascal中的：

var matrix:array[0..99][0.99][0..1]of integer;

1	var matrix:array[0..99][0.99][0..1]of integer;

多维数组的初始化和一维数组类似。例如，我们经常需要定义方向常量：

const int dir[4][2] = { {1,0},{0,1},{-1,0},{0,-1} };

1	const int dir[4][2] = { {1,0},{0,1},{-1,0},{0,-1} };

这还可以直接写成：

const int dir[4][2] = { 1, 0, 0, 1, -1, 0, 0, -1 };

1	const int dir[4][2] = { 1, 0, 0, 1, -1, 0, 0, -1 };

多维数组的初始化同样是未定义者自动填零，因此还可以写成：

const int dir[4][2] = { [0][0]=1, [1][1]=1, [2][0]=-1, [3][1]=-1 };

1	const int dir[4][2] = { [0][0]=1, [1][1]=1, [2][0]=-1, [3][1]=-1 };

程序中使用多维数组时必须用多个方括号，即dir[2][1]不能写成dir[2,1]。

当多维数组作为函数的参数时，只有第一维的大小可以不写。因此，下面的三个函数中前两个是合法的，第三个是不合法的。

long function_1( int m, int n, long a[20][20] );
long function_2( int m, int n, long a[][20] );
long function_3( int m, int n, long a[][] );

long function_1( int m, int n, long a[20][20] );

long function_2( int m, int n, long a[][20] );

long function_3( int m, int n, long a[][] );

为了让参数仍然适用于各种大小的数组，C语言允许这样定义函数：

long function_4( int m, int n, long[m][n] );

1	long function_4( int m, int n, long[m][n] );

例如，下面的函数递归地计算行列式：

long determinant( int n, long a[n][n] )
{
    if (n==1) return(a[0][0]);
    
    int i,j,k;
    long ans = 0;
    long sub[n-1][n-1];
    
    for ( i=0; i<n; i=i+1 )
    {
        for ( j=1; j<n; j=j+1 )
        {
           for ( k=0; k<i; k=k+1 )
              sub[j-1][k]=a[j][k];
           for ( k=i+1; k<n; k=k+1 )
              sub[j-1][k-1]=a[j][k];
        }
        ans = ans + (1-i%2*2)*a[0][i]*determinant(n-1, sub);
    }
    return ans;    
}

long determinant( int n, long a[n][n] )

{

if (n==1) return(a[0][0]);

int i,j,k;

long ans = 0;

long sub[n-1][n-1];

for ( i=0; i<n; i=i+1 )

{

for ( j=1; j<n; j=j+1 )

{

for ( k=0; k<i; k=k+1 )

sub[j-1][k]=a[j][k];

for ( k=i+1; k<n; k=k+1 )

sub[j-1][k-1]=a[j][k];

}

ans = ans + (1-i%2*2)*a[0][i]*determinant(n-1, sub);

}

return ans;

}

下面的代码片段正确地调用了上面的函数：

long a[4][4]={
               { 1, 4, -1,  4 },
               { 2, 1,  4,  3 },
               { 4, 2,  3, 11 },
               { 3, 0,  9,  2 }
             };
printf( "%d" , determinant(4,a) );

long a[4][4]={

{ 1, 4, -1, 4 },

{ 2, 1, 4, 3 },

{ 4, 2, 3, 11 },

{ 3, 0, 9, 2 }

};

printf( "%d" , determinant(4,a) );

结构的定义、初始化和使用
Pascal中的记录类型在C语言中叫做“结构”。定义一个结构的方式如下：

struct 结构名
{
   在此定义若干变量（域）
};

struct 结构名

{

在此定义若干变量（域）

};

注意花括号后面需要有一个分号。下面定义一个date结构：

struct date
{
   int year;
   short month,day;
};

struct date

{

int year;

short month,day;

};

这样你就获得了一个名为struct date的类型名。和变量的定义一样，一个结构的定义只能供当前函数（的当前语句块）中后面的部分使用。因此通常把结构的定义放在所有函数的前面作为一个全局的定义。之后，你便可以写这样的语句：

struct date today;

1	struct date today;

结构的使用方法同Pascal的记录类型一样。例如，下面的函数用于计算某一天是星期几（Zeller公式）：

int zeller( struct date t )
{
   if (t.month<3)
   {
      t.year = t.year - 1;
      t.month = t.month + 12;
   }
   int c = t.year / 100;
   int y = t.year % 100;
   int ans = ( c/4 - 2*c + y + y/4 + (26*(t.month+1))/10 + t.day - 1 ) % 7;

   if (ans>0) return ans;
   else return ans+7;
}

int zeller( struct date t )

{

if (t.month<3)

{

t.year = t.year - 1;

t.month = t.month + 12;

}

int c = t.year / 100;

int y = t.year % 100;

int ans = ( c/4 - 2*c + y + y/4 + (26*(t.month+1))/10 + t.day - 1 ) % 7;

if (ans>0) return ans;

else return ans+7;

}

给一个结构赋初始值和数组的初始化差不多。下面两个语句是等价的：

struct date myBirthday = { 1988, 5, 16 };
struct date myBirthday = { .year=1988, .month=5, .day=16 };

1 2	struct date myBirthday = { 1988, 5, 16 }; struct date myBirthday = { .year=1988, .month=5, .day=16 };

这种方法也可以用于程序中的赋值操作，但需要加上一个类型转换（见这里的“名词动用”一节）。例如，下面三个代码片段都是等价的：

myBirthday.year = 1988;
myBirthday.month = 5;
myBirthday.day = 16;
myBirthday = (struct date){ .year=1988, .month=5, .day=16 };
myBirthday = (struct date){ 1988, 5, 16 };

myBirthday.year = 1988;

myBirthday.month = 5;

myBirthday.day = 16;

myBirthday = (struct date){ .year=1988, .month=5, .day=16 };

myBirthday = (struct date){ 1988, 5, 16 };

下面的语句调用了zeller函数，输出自1583年来的每个13日都是星期几。和本文无关的问题：有人知道为什么我从1583年开始算么？

int y,m;
for ( y=1583; y<=2000; y=y+1)
   for ( m=1; m<=12; m=m+1 )
      printf( "%d ", zeller( (struct date){y,m,13} ) );

int y,m;

for ( y=1583; y<=2000; y=y+1)

for ( m=1; m<=12; m=m+1 )

printf( "%d ", zeller( (struct date){y,m,13} ) );

17Q&A-Week2

Q：求\(y=\sqrt{x^{2}-2x+2}+ \sqrt{x^{2}-4x+8}\)的最小值

Q：电容器串联会怎么样？

Q：手机充电器放在插座上会耗电吗？

Q：镀锌的时候如何控制[H+]不放电？

17Q&A-Week1

Q：求证1 + 1 = 2

Q：已知x为男生，命题“若x是人，则x是男人”为真。可是该命题的逆否命题。。

Q：高尔基体、生长素和抗原分别是什么？

忽然感觉存在感高了好多

Status

C语言速成手册（四）：指针、动态内存分配、标准输入

C语言速成手册（三）：数组、字符串、结构

朋友们

TAG CLOUD