c++ 简单的形参使用

 只想到这些以后还有再补充

#include<iostream>
using namespace std;
int* switch_int1(int a, int b)
{
    //错误！！
    //该int r[]局部变量在内存栈区，当退出函数后，该内存即被系统回收
    //所以返回的r[]的指针的值就会改变
    //因形参为局部变量，相当于将实参的值复制来一个新的局部变量内，使用规则同r[]
    //所以main函数内的ab的值不会改变
    int temp = b;
    b = a;
    a = temp;
    int r[] = { a,b };
    return r;
}
int* switch_int2(int a, int b)
{
    //正确！！
    //该static int r[]静态局部变量在内存全局区，当退出函数后，该内存也不会被系统回收
    //所以返回的r[]的指针的值不会改变，
    //注意静态局部变量的作用域只在该函数内，函数外无法调用
    //静态全局变量的作用域则为整个页面
    //全局变量的作用域为整个程序
    int temp = b;
    b = a;
    a = temp;
    static int r[] = { a,b };
    return r;
}
int *& switch_int3 (int& a, int& b)
{
    //正确！！
    //形参为引用的实参地址，所以对形参的值改变会影响到实参
    //返回值为一个指针引用，引用的静态数组指针，所以返回该引用后依然能获得数组内的值。
    int temp = b;
    b = a;
    a = temp;
    static int r[] = { a,b };
    int* r_ = r;
    return r_;
}
int *& out_prar_int4(int* a, int*& b)
{   //传出函数内的值
    //正确！！最为常用
    //a类型为指针 b类型为指针引用改变他们所指向的值都可以改变实参
    //注意switch_int4(A, &b);这种参数不能使用
    int q=5,e=6;
    *a = 5;
    * b = e;
    static int r[] = { *a,*b };
    int* r_ = r;
    return r_;
}
int*& out_prar_int5(int* a, int*& b)
{   //传出函数内的值
    //错误！！
    //a = Q改变的是指针的值 并没有改变指针所引用的地址内的值，在函数结束后所有局部指针也失效
    //实参未发生改变
    //但r[]由于是静态 所保存的是a解引用的值，而a之前赋值为q的引用，所以r[]的返回值正常
    int q = 5, e = 6;
    int* Q = &q, * E = &e;
    a = Q;
    b = E;
    static int r[] = { *a,*b };
    int* r_ = r;
    return r_;
}
void out_prar_int6(int(**y)[4])
{   //传出函数内的值
    //正确
    //实参为数组指针 形参为数组指针的指针
    //将y_ar的地址分配给指针的指针，在函数结束后 指针的指针 会丢弃，而里面的指针会保留 随即里面的地址也会保留
    //在函数外可以还原为数组
    //注意*y = &y_ar;要加& 这样类型才为数组指针。
    static int y_ar[] = {5,6,7,8};
    *y = &y_ar;

    return ;
}
void out_prar_char7(char(&char_addr)[5], char(*&tts_c)[5])
{
    //正确！
    //示例char的如何传值，原理与int一样
    //注意char数组传值使用strcpy_s函数
    static  char wwws[] = "asdf";
    strcpy_s(char_addr, 5, wwws);

    tts_c = &wwws;



    return;
}
int main()
{

    //int a = 2, b = 5;
    //int* A = &a, * B = &b;
    //int* x = switch_int1(a, b); 
    //int* x = switch_int2(a, b);
    //int* x = switch_int3(a, b);
    //int* x = out_prar_int4(A, B);
    /*int* x = out_prar_int5(A, B);
    cout << x[0] << endl;
    cout << x[1] << endl;
    cout << a << endl;
    cout << b << endl;
    cout << A << endl;
    cout << B << endl;*/
    //-------------------------------
    //int(*yy)[4] ;
    //out_prar_int6(&yy);
    //cout << (*yy)[2] << endl;
    //-------------------------------
    char ch[5] = {};
    char(*ch_z)[5];
    out_prar_char7(ch, ch_z);
    cout << ch << endl;
    cout << *ch_z << endl;
    return 0;
}

-----

补充 类 和new的一些问题

class *A =new class；

创造一个动态分配内存的类指针

可以使用 class&B=*A；得到该类的对象，

类中的属性为指针 对应有new时 需写析构函数来对其释放

结尾使用delete（A）或 delete（&B）；对类释放，

遇到函数就会变得复杂起来

void fun（class &b）

{

class E（b）；

retrun；//返回时E会首先结束 调用析构函数 对类中的属性有new进行了一次释放 而程序结尾对B进行delete时 也会调用析构函数 造成重复释放的错误

//解决方法当然是深度拷贝

}