C++基础入门(02)_引用

1
2
3
4
5
6
7
8
9
10
11
12
13

//1.引用作为函数参数
void func(int &a, int &b)
{
    int sum = a + b;
    cout << "sum=" << sum << endl;
}

void test01()
{
    int a = 10;
    int b = 20;
    func(a, b);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//2.引用作为函数的返回值
int& func2()
{
    int b = 10;//注意1：不要返回局部变量的引用
    int &p = b;
    return p;
}
int &func3()
{
    static int b = 10;
    return b;
}
void test02()
{
    int &q = func2();
    q = 100;
    cout << q << endl;

    func2() = 200;
    cout << q << endl;
////---------上面的代码是错误，只是编译器没有检测出来
    cout << "func2="<<func2() << endl;

    func3() = 100;//注意2：如果要函数当左值，那么该函数必须返回引用
    cout << "func3()=" << func3() << endl;
}

1
2
3

int &ref=10;//err
const int &ref2=10;//ok
原理是:int tmp=10;const int &ref=tmp;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#define ADD(x,y) x+y
//在普通函数前面加上inline是向编译器申请成为内联函数
//注意：加inline可能成为内联函数，可能不成为内联函数
inline int Add(int x, int y)
{
    return x + y;
}

void test()
{
    //10+20*2
    int ref = ADD(10, 20) * 2;
    cout << "ref=" << ref << endl;

    int ref2 = Add(10, 20) * 2;
    cout << "ref2=" << ref2 << endl;
}

#define COMAPD(x,y) ((x)<(y)?(x):(y))
inline int func(int x, int y)
{
    return x < y ? x : y;
}
void test02()
{
    int a = 1;
    int b = 3;
    //                        ((++a)<(b)?(++a):(b))      
    //cout << "COMAPD(x,y)=" << COMAPD(++a, b) << endl;//3
    cout << "func=" << func(++a, b) << endl;//2
}

1
2
3
4
5
6
7
8
9
10
11
12

int myFunc(int a, int b = 0)//int b=0;这就是函数的默认参数，不一定是0
{
    return a + b;
}
void test01()
{
    //函数的默认参数的作用
    //当函数内常要用到形参的某个值，但偶尔要使用其他值
    //增加函数的灵活性
    cout << myFunc(10, 20) << endl;
    cout << myFunc(10)<< endl;
}

1
2
3
4
5
6
7
8
9
10
11

//注意1：函数的默认参数后面的参数必须都是默认参数
int myFunc2(int a, int b = 0, int c=2,int d=3)
{
    return a + b + c + d;
}
//注意2：函数的声明和实现不能同时有函数的默认参数
void myFunc3(int a, int b);
void myFunc3(int a, int b = 0)
{

}

1
2
3
4
5
6
7
8
9
10

//函数的占位参数,占位参数在后面运算符重载时区分前加加或后加加
void func(int a,int=10)//占位参数也有默认值
{

}

void test02()
{
    func(10);
}

1
2
3
4
5
6
7
8
9
10
11

//占位参数和默认参数混搭
void func2(int=10, int a=20)
{

}
void test03()
{
    func2();
    func2(10);
    func2(10,30);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//参数的个数不同
void func()
{
    cout << "func()" << endl;
}

void func(int a)
{
    cout << "func(int a)" << endl;
}

//参数的类型不同
void func(char c)
{
    cout << "func(char c)" << endl;
}
//参数的顺序不同
void func(int a, double b)
{
    cout << "func(int a, double b)" << endl;
}
void func(double b, int a)
{
    cout << "func(double b, int a)" << endl;
}

1
2
3
4
5
6
7
8
9
10
11
12

void test01()
{
    int a = 10;
    double b = 3.14;

    func();
    //func(b);// err double转换不了成为int或char
    func(a, b);
    func(b, a);
    char c = 'c';
    func(c);//char转换int成功，调用int参数的函数
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

//函数重载和函的默认参数一起使用
void myfunc(int a, int b = 0)
{
    cout << "myfunc(int a, int b = 0)" << endl;
}

void myfunc(int a)
{
    cout << "myfunc(int a)" << endl;
}

void test02()
{
    //myfunc(10); err,二义性问题，不知道调用哪个函数
}

1
2
3
4
5
6
7
8
9
10
11
12
13

test.h文件中

//这是告诉C++编译器，找下面的函数，要以C语言的方式去寻找
#ifdef __cplusplus
extern "C"
{
#endif
    void func();//C语言的函数声明


#ifdef __cplusplus
}
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Maker//这个是类
{
public:
    int a;//成员属性（成员变量）
    void func()//成员方法（成员函数）
    {
        cout << "func" << endl;
    }
};

int main()
{
    Maker m;//m就是对象

    system("pause");
    return EXIT_SUCCESS;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

//封装：1,把属性和方法放到类中,2.给这些数据赋予权限
class Maker
{
public://公有权限
    void set(string Name,int Id)
    {
        id = Id;
        name = Name;
    }
    void printMaker()
    {
        cout << "id=" << id << " name=" << name << endl;
    }
private://私有
    int id;
    string name;

protected://保护
    int a;
};
//继承
class Son :public Maker
{
    void func()
    {
        a = 20;//子类的类内可以方法父类的保护权限的成员

    }
};
//类外不能访问私有权限的成员
//类外可以访问公有权限的成员
//类外不能访问保护权限的成员
//子类的类内可以方法父类的保护权限的成员
//类内是没有权限之分

void test()
{
    Maker m;
    m.set("小花",1);
    m.printMaker();


}