C++（1）的引入和基本的一些概念

一：c和c++差异
  c: 面向过程：算法+数据结构 = 程序
  c++:面向对象：算法+数据结构 = 对象  对象+通讯机制=程序

二：const
    {
        c：const修饰的变量，在c语言里是可以被指针间接修改的

#include <stdio.h>

int main(int argc, char *argv[])
{ 
    const int a=5;
    int *p=&a;
    *p=9;
    printf("%d\n",a);

    return 0;
} 

        c++：const修饰的变量，不能被修改

#include <stdio.h>

int main(int argc, char *argv[])
{ 
    const int a = 5;
    int *p = &a;

    *p = 9;

    printf("%d\n", a);

    return 0;
} 

运行结果

    }
    define{
        c：使用define定义常量
        c++：一般不会使用define定义常量，而是用const
    }
    
三：
    引用{
        int a = 5;
        int &b = a;
        引用就是取别名，
        引用的作用{
            1.作为参数，新参改变就是实参改变
            2.作为返回值，返回的是变量本身而不是变量的值
        }

c:

#include <stdio.h>

int main(int argc, char *argv[])
{ 
    int a = 5;
    int &b = a;

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

    return 0;
} 

运行

  报错

c++:

#include <stdio.h>

int main(int argc, char *argv[])
{ 
    int a = 5;
    int &b = a;
   //a和b的值和地址都一样，说明引用就是一个取别名，两个名字对应同一片空间
    printf("a=%d b=%d &a=%p &b=%p\n", a, b, &a, &b);

    return 0;
} 

运行

 引用的作用：

#include <stdio.h>
/*
void swap(int a, int b)         //赋值传递，形参不能改变实参的值
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}
*/
/*
void swap(int *a, int *b)  //地址传递可以改变实参的值，不过会有两个多余的变量
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}
*/

void swap(int &a, int &b) //引用，a和b就是实参本身，所以可以改变实参的值
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}

int & setval(int &a)   //返回值为引用，返回的是变量本身而不是变量的值
{
    a = 15;
    return a;
}

int main(int argc, char *argv[])
{ 
    int a, b;
    a = 5;
    b = 6;
    
    swap(a, b);
    printf("a=%d b=%d\n", a, b);

    setval(a) = 9;
    printf("a=%d\n", a);
    return 0;
} 

 }
四： 
    函数重载
        相同的函数名，不同的参数（类型，数目，）
        行为相识，逻辑不同使用重载
        行为相同，逻辑相同应该用模板

c++：

#include <stdio.h>

int add(int a, int b)
{
    printf("111111\n");
    return a + b;
}

int add(int a, int b, int c)
{
    printf("2222222\n");
    return a + b + c;
}

double add(int a, double b)
{
    printf("33333333\n");
    return a+b;
}


int main()
{
    int a = 1,b = 2,c = 3;
    double d = 4.13,e = 3.14;
    /*
	第一个和第二个是参数的个数不同
	第一个和第三个是参数的类型不同
	他们都会自动匹配调用相应的函数
   */
    add(a,b);  
    add(a,b,c);
    add(a,d);

}

重载和默认参数的歧义

#include <stdio.h>

int add(int i, int j = 2, int k = 3);
int add(int i, int j);

int add(int i, int j, int k)
{
    return i + j + k;
}

int add(int i, int j)
{
    return i + j;
}



int main()
{
    int i = 5, j = 6;

    printf("%d\n", add(i));
//add(i,j) 这里不知道是使用三个参数的还是使用两个的所有会有歧义
}

        
五：
    默认参数
        注意！！！！ 默认参数只能写在函数的声明
        1.传参只能从左往右
        2.默认参数一定是从右到左
        
六：
    c NULL代表空指针，是0
    c++ nullptr代指无效指针
 

#include <stdio.h>

int main(int argc, char *argv[])
{ 
	//NULL代表空指针，但是可以赋值给一个整型变量这是不合理的，所以c++使用nullptr代表无效地址
    unsigned long a = NULL;

    return 0;
} 

七：
    mutable    修饰的变量可以被更改
    mutable 不能和const和static直接连用

#include <stdio.h>

int main(int argc, char *argv[])
{ 
   //const修饰的变量不能改变，但是c语言可以通过指针去间接改变不合理，c++不允许
    const int a = 5;
    int *p = &a;

    *p = 9;

    printf("%d\n", a);

    return 0;
} 

#include <stdio.h>
struct demo
{
    int a;
    mutable int b;
};
int main()
{
    struct demo A ={100,102};
    A.b=90;
    printf("%d,%d\n",A.b,A.a);
    return 0;
}

    
八：
    内敛函数：直接展开函数体（效率会更高）
              限制：逻辑简单的函数，不会有复杂逻辑（不能有switch，for）
                    一般不超过5行
    inline: 在函数声明的位置直接实现（一般不会有函数声明）

#include <stdio.h>

inline int add(int a, int b)
{

	return a+b;
}

int main()
{
	int sum = add(1,2);
	printf("sum=%d\n", sum);
}

九：
    开辟空间与释放{
        c:malloc开辟， free释放   函数
        c++：new开辟（异常处理失败的情况）， delete释放 运算符

#include <stdio.h>


int main()
{
#if 0
	int *p = (int*)malloc(sizeof(int));
	if(NULL == P)
		perror("malloc");

	*p = 5;

	free(p);
	int *a = new int;

	*a = 5;

	delete a;
#endif
    int *p = new int[5];

    p[0] = 2;

    printf("%d", p[0]);

    delete []p;

}

        
        malloc(sizeof(int)*n)
        new int[n]
        
        free(p)
        delete []p;
        
    }
十：
    作用域
    c：全局，局部
    c++：局部，全局，类域，名词空间
    namespace
        

#include <stdio.h>

namespace my{
	int a = 2;
}

int main()
{
	int a = 1;

    printf("%d", my::a);

十一：
    全局变量
    

#include <stdio.h>
int a;
int a = 5;

int main()
{
	printf("a=%d\n", a);
}

c语言编译通的过

c++编译无法通过