C++知识点全回顾 第1天

工作太久，好多基础知识都快忘记了，趁最近不忙，做以下几件事情：

1、回顾C++全部基础知识点

2、了解和熟悉深度学习常用算法

3、开始学习python基础

/* 
//1、注意进制转化
void main(void)
{
    int a = 167;
    int b = 025;   //注意这是八进制
    printf("a=%d\n",a);
    printf("b=%d\n",b);  //转化为10进制为，2*8+5 = 21；

}*/

/*
//2、copy 字符串函数
void copystr(char* str1,char* str2)
{
    while(*str2!='\0')
        *str1++=*str2++;
        *str1='\0';
}

int main()
{
    char a[6];
    char b[]="abcdef";
    copystr(a,b);
    cout<<"a= "<<a<<endl;
    return 0;
}

*/

/*
//3、数据类型转换
void main(void)
{
    short s1 = 1;
    //s1 = s1+1l;  //s1为short类型 + 一个long类型1会转换为long类型，然后再把long类型转换为short需要强制转换
    //s1 = (short)(s1+1l);  //正确做法
    s1 += 1l;  //正确做法，因为+=运算符已经做了强制转换
    printf("s1=%d\n",s1);
}*/

/*
//4、字符与字符串 注意字符串结束符
void main(void)
{
    char a[]={"abcd"};
    char b[]={'a','b','c','d'};
    //注意字符串a实际长度是5；隐藏了结束符\0；实际内容是abcd\0；
    //char a[5]={"abcd"};
    //char b[4]={'a','b','c','d'};
    char A[] = "a";
    char B ='a';
    printf("sizeof(A)=%d\n",sizeof(A));    //sizeof(A)=2;
    printf("sizeof(B)=%d\n",sizeof(B));    //sizeof(B)=2;
    // 因此"a"!='a'
}*/

/*
//5、前增量 后增量
void main(void)
{
    int a,b,c,d;
    a = 10;
    b = a++;
    printf("a=%d；b=%d\n",a,b);    //拆分：1、b=a；2、a=a+1；所以 a=11;b=10
    c = ++a;
    printf("a=%d；c=%d\n",a,c);    //拆分：1、a=a+1；2、c=a；所以 a=12;c=12
    d = 10 * a++;
    printf("a=%d；d=%d\n",a,d);    //拆分：1、d=10 * a；2、a=a+1；所以 d=120;a=13
}*/

/*
//6、运算符优先级问题
void main(void)
{
    if(0&1==0)       //运算符 == 高于 &；所以if条件不成立
    {
    printf("0&1==0 \n");
    }
    else
    {
    printf("0&1 !=0 \n");    
    }

    if(0&1!=0)       //运算符 != 高于 & ;所以if条件成立
    {
    printf("0&1 !=0 \n");
    }
    else
    {
    printf("0&1==0 \n");
    }
}*/

/*
//7、宏定义参数替换注意括号保护优先级
#define DIVISION(a,b) (a/b)

float divfuc(float a,float b)
{
    return a/b;
}

void main(void)
{
    float a = 4;
    float b = 2;
    printf("divfuc =%f\n",divfuc(a+b,a-b));
    printf("DIVISION =%f\n",DIVISION(a+b,a-b));
}
// divfuc(a+b,a-b) = 3.000000
// DIVISION(a+b,a-b) = 2.500000  因为宏定义把参数替代结果为a+b/a+b; 4+2/4-2;结果改变为2.5
#define DIVISION(a,b) ((a)/(b))   //正确写法
1、宏的引用只占编译时间，不占运行时间。
2、宏的定义没有返回值，如果需要，需要给整个表达式加括号。
3、宏的形参没有数据类型，函数的形参必须有数据类型。
4、实参为表达式的情况，如果没有给表达式加上括号，可能会导致错误的结果，而函数不会。
5、宏直接替代有可能导致副作用，函数不会。
*/

/*
// 8、关于宏定义取最大值最小值
#define MIN(a,b) ((a)>(b)?(b):(a))
#define MAX(a,b) ((a)>(b)?(a):(b))
*/

/*
// 9、define 与 typedef区别
#define PCHAR char*
typedef char* pchar;
void main(void)
{
    PCHAR a,b;   //宏定义替换结果是 char* a,b ；a为字符指针，b为字符变量
    pchar x,y;
    printf("sizeof(a)=%d sizeof(b)=%d\n",sizeof(a),sizeof(b));     //sizeof(a) =4 ;sizeof(b)=1
    printf("sizeof(x)=%d sizeof(y)=%d\n",sizeof(x),sizeof(y));     //sizeof(x) =4 ;sizeof(y)=4
}

1、typedef一般用来定义一种数据类型的别名，define主要是用来定义常亮或者复杂而且频繁使用的表达式
2、执行时间不同，typedef虽然不分配内存，但却是编译过程的一部分，有数据类型检查功能，
                 define是预编译的部分，放在编译之前，只是对宏定义内容进行简单替换，不进行类型检查
3、作用域不同，typedef是有作用域的define却是不收作用域限制，只要在define申明之后的引用都是正确的
4、对指针的别名操作有不同。define定义的类型别名代表指针时，其连续申明的变量只有第一个是指针，其他的均为费指针类型的普通变量
   而typedef能保证连续声明的所有变量均为同一类型。
5、另外typedef是语句，句尾要加分号，而define不是语句，句尾不用加分号
*/

/*
//10、const 关键字
const int a;   //定义了一个常整形变量a
int const a;   //定义了一个常整形变量a
const int *a;  //定义了一个指向常整形数据的指针a  指针地址可以变，但是指针指向的整形数据不变
int const *a;  //定义了一个指向整形数据的常指针a  指针地址不能变，但是指针指向的整形数据可以变
int const *a const;   //定义了一个指向常整形数据的常指针a  指针地址和指向的整形数据都不能变
*/

/*
//11、const 和 define的区别
1、用const定义常量在编译的时候提供数据类型安全检查，而define只是简单的进行替换
2、很多集成开发环境可以支持const常量调试，而不支持define定义的常量调试
3、const定义的常量会分配内存空间；define没有分配内存空间。
总结：定义常量时候const有优势，但是define还可以支持带参数的宏，这点const无法支持。
*/

/*
//12、static和extern
//static主要定义全局静态变量，局部静态变量，定义静态函数
如果没有赋默认值，则static静态数据默认值为0

static int a;
void fuc(void)
{
    static int a;
    printf("fuc-a=%d\n",a);
    a=a+1;
    printf("fuc-a=%d\n",a);
}

void main(void)
{
    fuc();
    //printf("main-a=%d\n",a);
}*/

/*
//13、C++中static可以定义静态数据成员和静态数据函数,如果没有赋默认值，则static静态数据默认值为0
class A
{
public:
    static int x;
    int y;
    static void seta(int i);
    static int geta();
    A();
    ~A();
};

int A::x=5;
A::A()
{
    y=6;
}
A::~A()
{

}

void A::seta(int i)
{
    x=i;
}

int A::geta()
{
    return x;
}
void main(void)
{
    printf("A::get()=%d\n",A::geta());
    A::seta(9);
    printf("A::get()=%d\n",A::geta());
    A a;
    printf("a.get()=%d\n",a.geta());
    a.seta(8);
    printf("a.get()=%d\n",a.geta());
}*/

/*
//extern表示将变量和函数声明为外部链接，变量默认是内部链接。函数默认是外部链接，声明时有无extern都可以通过链接。
而全局变量则不行。通常在模块的头文件中，对本模块提供给其他模块引用的函数和全局变量以关键字extern声明。也就是说C
头文件里面定义了一个函数或者变量，如果该函数和变量要开放给外部，则在.h文件中使用extern加以声明。外部文件需要include
该.h文件就可以了，并且编译阶段，外面找不到该函数的但是不报错，link阶段会从定义的模块生产的目标代码中找到该函数和变量。
*/

/*
//14、引用
void swap1(int &x,int &y)
{
    int temp = 0;
    temp = x;
    x=y;
    y=temp;
    printf("in swap1 &x=%d; &y=%d\n",&x,&y);
}

void swap2(int x,int y)
{
    int temp = 0;
    temp = x;
    x=y;
    y=temp;
    printf("in swap2 &x=%d; &y=%d\n",&x,&y);
}

void main(void)
{
    int a = 0;
    int b = 0;
    printf("in main &a=%d; &b=%d\n",&a,&b);
    swap1(a,b);
    swap2(a,b);
    return;
}
//可以看到函数swap1中引用形参x y并没有分配存储空间，其地址指向的是主函数的a,b。
//而函数swap2中的普通数值型形参却有自己的内存空间
*/

int &fuc1(int x)
{
    int temp;
    temp = x;
    cout<<"In fuc1 &temp is:"<<&temp<<endl;
    cout<<"In fuc1 temp is:"<<temp<<endl;
    return temp;
}

void main(void)
{
    int &a=fuc1(5);
    a = 9;
    cout<<"In main &a is:"<<&a<<endl;
    cout<<"In main a is:"<<a<<endl; 
}