学习C++（1）记载的一些网易云笔记

1.C语言中，未初始化的全局变量为0，未初始化的局部变量为垃圾值。C 支持全局变量的重复定义，而C艹不可以。

#include <iostream>

using namespace std;

int a;
int a = 1;

int main ()
{   
    cout << a << endl;
}

编译不通过。

2 . C 中的一些不好的使用方式

#include <stdio.h>
// 1 函数可以没有返回参数类型
f()
{
    printf ("hello world\n");
}

// 2 函数参数可以没有数据类型
g(i)
{
    return i;
}

int main()
{
    // 3 没有参数的函数可以接收任意个参数
    f(1,2,3,4,5);

    g(12,15);

    return 0;
}

3.下面语句在 C 中不可以使用，因为 a 是一个寄存器变量， 取地址符只能取内存变量，但是在 C艹 中可以，这时 a 不再是一个寄存器变量而是默认为普通变量。、

register int a；
&a;

4.三目运算符
在 C 中结果是将常量2 赋值给 C， 而不是把 B 赋值给 C，所以不能当做左运算符。
但是在C艹中完全可以，因为三目运算符的结果返回的是变量 B 。

int a = 2， b= 2 ;
Int c = (a < b) ? a : b ; 
(a < b) ? a : b  =  10； // c ++ 可行 ，c 不行

用 C 模拟 C艹 中的效果：

*（(a < b) ? &a : &b ; ）= 10

5.C语言中 struct 定义了一组数据的集合，而不是一种新的数据类型 。所以在定义变量的时候需要在前面加上 struct 关键字进行修饰。C++中 struct 定义了一种新的数据类型，可以直接用来定义变量。

#include <iostream>

using namespace std;

struct test
{
    int i;
};

int main ()
{
    test t;
    return 0;
}

6.const 在 C 中是只读变量，不能通过变量的方式来修改，可以通过其他方式修改，比如指针。在 C艹 中 const修饰变量为常量，存在于符号表，不占用内存，相当于define。

#include <iostream>

using namespace std;

int main ()
{
    const int a = 1;
    int *p = (int *)&a;

    *p = 3;

    cout << *p << " " << a << endl;
    return 0;
}

7.在C艹中define和const的区别。
前者作用域是从这一行往下。
后者作用域可为局部变量。

#include <iostream>

using namespace std;

void print()
{
    const int a = 1;
    #define b 2
    cout << a << " " << b << endl;
    #undef b
}

int main ()
{
    print();
//  cout << a << endl;
    cout << b << endl;
    return 0;
}

8.定义一个引用时，一定要初始化。

Int a = 1;
int &b = a;

在C艹里引用实现是一个常指针，因此引用所占的空间是指针的大小。
const 的就近原则

#include <iostream>

using namespace std;

struct test
{
    char &a; 
    char &b; 
};


int main ()
{
    int a = 1;
    int &b = a;
    char c = 'a';
    char &d = c;

    const int *p;                 //const就近原则
//  int * const p;
//  const int * const p;
    (*p)++;

    cout << sizeof(b) << endl;
    cout << sizeof(d) << endl;
    cout << sizeof(test) << endl;
    return 0;
}

10.利用引用交换变量的值。

#include <iostream>

using namespace std;

void swap (int &x, int &y)
{
    int tmp = x;
    x = y;
    y = tmp;
}

void swap (int *x, int *y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}

void swap()
{
    cout << "my cat is very cute" << endl;
}

int main ()
{
    int a = 1, c = 2;
    int &b = a; //引用要注意初始化

    cout << b << endl;

    swap(a , c);//利用引用来交换变量的值
    cout << a << " " << c << endl;

    swap(&a , &c);
    cout << a << " " << c << endl;

    swap();
    return 0;
}

11.C++中的布尔类型
C++在C语言的基本类型系统之上增加了bool
C++中的bool可取的值只有true和false
理论上bool只占用一个字节，
如果多个bool变量定义在一起，可能会各占一个bit，这取决于编译器的实现

true代表真值，编译器内部用1来表示
false代表非真值，编译器内部用0来表示

bool类型只有true（非0）和false（0）两个值
C++编译器会在赋值时将非0值转换为true，0值转换为false

#include <stdio.h>

int main()
{
    bool b = true;
    printf ("%d, %d\n", b, sizeof(b));

    int a = 10;
    b = 3;
    a = b;
    printf ("a = %d, b = %d\n", a, b);

    b = -5;
    a = b;
    printf ("a = %d, b = %d\n", a, b);

    b = 0;
    a = b;
    printf ("a = %d, b = %d\n", a, b);

    b++;
    printf ("a = %d, b = %d\n", a, b);

    b += 1;
    printf ("a = %d, b = %d\n", a, b);
    return 0;
}

12.C++中可以在函数声明时为参数提供一个默认值，当函数调用时没有指定这个参数的值，编译器会自动用默认值代替。

#include <iostream>

using namespace std;


int add(int a, int b, int , int)
{
    return a + b;
}

/*
int add (int a ,int b, int = 0, int = 0)
{
    return a + b;
}
*/

int main ()
{
    add(1, 2, 3, 4); 
  //add(1, 2);
    return 0;
}

13.

//存在默认参数无实参时，使用默认参数。
//存在默认参数有实参时，使用实参。
//默认参数后，都必须使用默认参数
#include <iostream>

using namespace std;

int add (int a , int b = 10, int c = 10) 
{
    return (a + b + c); 
}

int main ()
{
    int ret; 
    ret = add(1, 2); 
    cout << ret << endl;

}

14.

#include <iostream>
#include <cstring>
#include <cstdlib>

using namespace std;


void InitMemory(char *&str)  //指针的引用
{
    str = (char *)malloc(100);
}

int main ()
{
    char *ptr = NULL;

    InitMemory(ptr);

    strcpy(ptr, "my cat is very cute");

    cout << ptr << endl;
    return 0;
}

15.

#include <iostream>

using namespace std;

int main ()
{
    // int &a = 1 ; 不可以用常量初始化常引用

    const int &a = 1;
    //可以用常量初始化常引用
    // a++;不可
    int *p = (int *)&a;
    (*p)++;
    //通过指针修改
    cout << a << endl;


    int b = 1;
    const int &c = b;
    //用变量初始化常引用
    //c++;不可
    b++;
    cout << c << endl;

    return 0;
}

16.

//构成重载的条件：1.参数的个数不同 2.参数的顺序不同 3.参数的类型不同
//返回值不同不可以构成重载

#include <iostream>

using namespace std;

int add (int x, int y)
{
    return x + y;
}

double add (double x, double y)
{
    return x + y;
}

int main ()
{
    add(1, 2); 
    add(2.00, 3.00);
    return 0;
}

17.函数重载和函数指针一起使用

#include <iostream>

using namespace std;

int add (int x, int y)
{
    return x + y;  
}

double add (double x, double y)
{
    return x + y;
}

int main ()
{
    int (*p)(int, int);
    p = add;
    cout << p(1, 2) << endl;

    double (*q)(double, double);
    q = add;
    cout << q(1.f, 2.3) << endl;

    return 0;
}