c知识点总结2

函数

int func(int x){        //x：形式参数
    ....
}

int main(){
    ....
    int res=func(z);    //z：实际参数
}

实参与形参具有不同的存储单元，

实参与形参变量的数据传递是“值传递”；

函数调用时，系统给形参分配存储单元，并将实参对应的值传递（copy）给形参；

P.S. 实参与形参的类型必须相同或可以兼容；

示例：

#include<iostream>
using namespace std;
void exchange(int a, int b){
    int p;
    p = a; a = b; b = p;
}
int main(){
    int a = , b = ;
    exchange(a, b);
    cout<<a<<" "<<b<< endl;
    return ;
}

输出结果将会是3 5.  因为在调用exchange()时，main函数里的a和b的值被copy给exchange()，然后修改的是exchange函数内存空间里的a和b，而不是main函数内的。那如何实现exchange功能呢？可以用指针

#include<iostream>
using namespace std;
void exchange(int *a, int *b){
    int p;
    p = *a; *a = *b; *b = p;
}
int main(){
    int a = , b = ;
    exchange(&a, &b);
    cout<<a<<" "<<b<< endl;
    return ;
}

如果是数组作为函数参数呢？

#include <iostream>
using namespace std;
void change(int a, int b){
    a = ; b = ;
}
int main()
{
    int a[] = {, };
    change(a[], a[]);
    cout<<a[]<<" "<<a[]<<endl;
    return ;
}

这里数组元素a[0]和a[1]和普通变量一样，是直接值拷贝过去的。所以输出还是3 5

#include <iostream>
using namespace std;
void change(int z[]){
    z[] = ; z[] = ;
}
int main(){
    int a[] = { ,  };
    change(a);
    cout << a[] <<" "<< a[] << endl;
    return ;
}

返回结果是30 50.  这里参数传递的时候copy的是数组a的名字（a是一个常量，表示数组a在内存中的地址）。这样change函数内就直接找到a[0]和a[1]对应的内存空间进行修改了。

函数执行结束之后，函数内的所有内容（eg 局部变量）都会被销毁

---

指针

&x  取变量x的地址

*p  取地址p中的内容

*&x   等价于   x

int *p;                    //指针变量，存放地址。
int c=;
int d=;
int e=;
p=&c;                      //表示把c的地址赋给p
cout<<c<<" "<<*p<<endl;    //888 888
*p=;                    //表示把p所指向的存储单元（也就是c）的内容改成666
cout<<c<<" "<<*p<<endl;    //666 666
c=d;                       //再改成999
cout<<c<<" "<<*p<<endl;    //999 999
*p=e;                      //再改成233
cout<<c<<" "<<*p<<endl;    //233 233 

两个例子：

     int ic=;
     int *ip=⁣
     *ip=;
     cout<<ic<<endl;
     cout<<ip<<endl;
     cout<<&ic<<endl;
     cout<<*ip<<endl;
     cout<<&ip<<endl;    //指针变量的地址

 Output: 

 0x7ffe4b072e04
 0x7ffe4b072e04

 0x7ffe4b072e08

 ---------------------------------------------------

     int a=,b=;
     int *p1=NULL, *p2=NULL;
     int *tmp=NULL;
     p1=&a;
     p2=&b;
     if(*p1>*p2){
         tmp=p1;  p1=p2;  p2=tmp;        //交换的是p1和p2两个指针
     }
     cout<<*p1<<" "<<*p2<<endl;
     cout<<a<<" "<<b<<endl;

对指针变量做++的含义：　　int *p;    p++;    //p=p+(sizeof(int));

指向数组的指针：

int a[10];   int *p;   p=a;

【 数组名相当于指向数组第一个元素的指针】
如果有一个  int a[4]={1,2,3,4};

• 若 a 是 指向数组第一个元素 的指针， 即a相当于&a[0]；
• a是指向a[0]的指针，a+1将跨越sizeof(int)=4个字节
• &a是“指向数组”的指针； &a+1将跨越4*sizeof(int)=16个字节；
  • &a 相当于 管辖范围“上升” 了一级；
• *a 是数组的第一个元素a[0]；即*a等价于a[0] ；
  • *a 相当于 管辖范围“下降” 了一级；

二维数组的指针

int a[3][3]={{1,2,3}, {4,5,6}, {7,8,9}};

a[0]  -  a[0][0] a[0][1] a[0][2]

a[1]  -  a[1][0] a[1][1] a[1][2]

a[2]  -  a[2][0] a[2][1] a[2][2]

a[0]是指向数组{a[0][0], a[0][1], a[0][2]}的第一个元素a[0][0]的指针，管辖范围 = sizeof(a[0][0]) = sizeof(int)

a是指向数组{a[0], a[1], a[2]}的第一个元素a[0]的指针，管辖范围 = sizeof(a[0]) = 3*sizeof(int)

&a是指向整个数组a的指针，管辖范围 = sizeof(a) = 9*sizeof(int)

• a与&a[0]等价
• a[0]与&a[0][0]等价
• a[0]与*a等价
• a[0][0]与**a等价
   
• 数组名相当于指向数组第一个元素的指针
• &E 相当于把E的管辖范围上升了一个级别
• *E 相当于把E的管辖范围下降了一个级别

指针操作字符串

char buf[]="ABC";
char *pc;
pc="hello";            //hello是常量，不能修改
cout<<pc<<endl;        //hello
pc++;
cout<<pc<<endl;        //ello
cout<<*pc<<endl;       //e
pc=buf;                //相同类型指针之间的赋值
cout<<pc<<endl;        //ABC

 指针作为函数参数

#include <iostream>
using namespace std;

int maxvalue(int (*p)[])        //p和a类型一样，是指向a[0]的指针
//int maxvalue(int p[][4])       //这样也可以。c编译器将形参数组名作为指针变量来处理
{
    int max = p[][];
    for(int i=; i<; i++)
    for(int j=; j<; j++)
    if(p[i][j]>max)
    max = p[i][j];
    *p[i]
    return max;
}
int main( )
{
    int a[][] = {{,,,},{,,,},{,,,}};
    cout<<"The Max value is "<<maxvalue(a);
    return ;
}

int maxvalue(int p[])
//int maxvalue(const int p[])           //如果想限制对原数组的修改，可以加const。
{
    int max = p[];
    for(int j=; j<; j++)
        if(p[j]>max)
            max = p[j];
    *p=;                           //可以这样修改原数组的值
    return max;
}
int main( )
{
    int a[] = {,,,};
    cout<<"The Max value is "<<maxvalue(a)<<endl;
    cout<<a[]<<endl;    //
    return ;
}

void mystrcpy(char *dest, const char *src){
    ......
    //保证src不会被修改
}
int main(){
    char a[] = “How are you!”;
    char b[];
    mystrcpy(b,a);
    cout<<b<<endl;
    return ;
}

int main(){
    const int a=;
    const int b=;
    int c=;

    const int *pi=&a;
    *pi=;     //不可以，*p是a，不能修改
    pi=&b;      //可以。p本身是可以修改的
    *pi=;     //不可以。*p是b，不能修改
    pi=&c;      //不可以。c是int，而pi是指向const int的指针
    *pi=;     //不可以
}

指针用做函数返回值

#include <iostream>
using namespace std;

int *get(int arr[ ][], int n, int m){
    int *pt;
    pt = *(arr + n - ) + m-;      //arr+n-1是指向int[4] {5,6,7,8}的指针，加一个*获取这个小数组的地址
    return(pt);
}

int main(){
    int a[][]={, , , ,
                 , , , ,
                 , , , ,
                 , , , };
    int *p;
    p = get(a, , );
    cout<<*p<<endl;
}

静态局部变量：函数中的局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不释放。在下一次该函数调用时，仍可以继续使用该变量；

#include <iostream>
using namespace std;

int *getInt1(){
    static int value1 = ;
    return &value1;
}
int *getInt2(){
    static int value2 = ;
    return &value2;
}
void func(){
    int a=;
    static int b=;                  //整个程序运行周期中只执行一次。函数退出后仍然保留b的值
    a++;
    b++;
    cout<<a<<" "<<b<<endl;
}

int main(){
    int *p,*q;
    p = getInt1();
    q = getInt2();
    cout << *p << endl;
    cout << *q << endl;
    for(int i=;i<;i++){
        func();
    }
    return ;
}

--------------------------------
output:

111