C++_C和C++的区别2

接上篇const的其它用法：
1、const - 形参：防止实参被修改、接收临时量（替代实参传递时的地址传递、形参为指针的定义）

int Mul(const int& a, const int& b)
{
    return a * b;
}

int main()
{
    int a = 10;
    int b = 20;
    Mul(10, 20);
    return 0;
}

2、const - * 、const - **：杜绝间接访问修改常量内存块的值 （int **p -> const int ** p（*q p））

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

//判断const的直接修饰对象以及间接修饰对象，查找是否存在间接修改变量的表达式，并用const修饰以防止修改变量
//const直接修饰对象为 *p即a 、则间接修饰对象为*p *q，*p以被const修饰，不存在修改变量a的可能 
//*q未被const修饰，存在修改变量的风险，在*q前加const 以保护变量a不存在被间接修改的可能    

    const int a = 10;
    const int* (const)p = &a;
    const int* (const)* q = &p;

//当存在大量const时，由上至下依次判断是否存在间接修改变量的可能
//第一个const修饰对象为变量a，可能间接修改变量a的对象为*p  **q(*q  p)  *p已被修饰，**q已被修饰
// *q p未被修饰 ，在*q p前加const修饰以保护变量a不存在被间接修改的可能 
//第二个const修饰变量为*p即a，同上  
//第三个const修饰变量为**q即为*p即a，同上
    return 0;
}

3、const - &：引用引用的变量不能取地址时常引用可以处理( 数值放到临时量（内存） 常引用引用临时量的内存单元)

int main()
{
    int a = 10;
    int& b = a;                          // 引用：取别名
    const int& c = 10;               // 引用规则：不能对不能取地址的变量或常量进行引用、可前加const来修改
    return 0;
} 

4、const - 返回值：不能返回局部变量地址引用、不能返回局部变量地址、可返回局部变量的值
int& getData(int data)
{
    int tmp = data;
    return tmp;                    
}
void func()
{}
int main()
{
    int val = 20;
    int& rrt = getData(val);      
    func();
    cout << rrt << endl;
    return 0;
}
//局部变量所开辟的内存会在该函数使用结束后由系统回收（可再分配）、再引用局部变量的地址，会访问非法区域，
//存在成功的可能性，但当系统回收的内存被再次分配后，再访问局部变量的地址就会出错

C和C++在开辟内存上的区别：
C语言使用malloc 函数进行空间的开辟
C + + 使用new 关键字进行空间的开辟

1、内存的开辟与释放：

 C  ：  int* p = ( int* ) malloc ( sizeof ( int ) );
            free(p);
C++： int* p = new int ;
            delete p;

2、数组的开辟与释放：

C  ：   int* p = ( int * ) malloc ( sizeof ( int )* 10 );
           free(p);
C++：int* p = new int [10];
           delete [] p;

4、二维数组的开辟与释放

C  ：   int** p = ( int** ) malloc ( sizeof ( int* )* 10 );
           for (int i = 0; i < 10; i++)
           {
                  p[i] = ( int* ) malloc ( sizeof ( int )* 10 );
           }
           for (int i = 0; i < 10; i++)
           {
                  free(p[i]);
           }
                  free(p);

C++： int** p = new int*[10];
           for (int i = 0; i < 10; i++)
           {
                  p[i] = new int[10];
           }
           for (int i = 0; i < 10; i++)
           {
                  delete[] p[i];
           }
                  delete[] p;

4、malloc和new的区别：

malloc ： 函数 、在堆区开辟内存
  new   ：关键字、自主存储区开辟

5、开辟内存返回值的区别：

C  ：开辟内存失败返回NULL
C++：开辟失败直接抛出异常

6、开辟常量内存块的开辟与释放：

C  ： 无法开辟常量内存块
C++：const int* p = new const int (10);
           delete p;

7、数组的开辟与初始化

C  ： 使用malloc开辟数组的同时无法进行初始化赋值
C++：使用new 开辟数组的同时可以进行初始化赋值，但是赋值的结果只能为全零
          int* p = new int[10]();
          cout<<p[0]<<p[1]<<p[2]<<p[3]<<p[4]<<p[5]<<p[6]<<p[7]<<p[8]<<p[9];输出为全零

8、new可以重载，malloc不可以
9、new可以调用malloc，malloc不可以调用new

C和C++的作用域：

C ：
        全局作用域
        局部作用域
C++：
        全局作用域
        局部作用域
        名字空间作用域     名字空间名称:: 名字空间作用域访问符
        类作用域                类:: 类作用域访问符

名字空间作用域：
#include<iostream>
using namespace std;

namespace CSDN
{
    int a = 11;
    int Sum(int a, int b)
    {
        return a + b;
    }
}
int main()
{
    using CSDN::a;                     //using声明  
    int b = a;                               //将CSDN名字空间作用域下的变量a暴露在当前函数中
    cout << b << endl;                //输出结果为11
    using namespace CSDN;     //using指示符  
    int rt = Sum(10, 20);             //将CSDN名字空间作用域下的全部内容暴露在当前函数中
    cout << rt << endl;                //输出结果为30
    return 0;
}

 

#include<iostream>
using namespace std;

namespace CSDN
{
    int a = 11;
    int Sum(int a, int b)
    {
        return a + b;
    }
}
namespace CSDN
{
    int b = 20;
}
int main()
{                
    using CSDN::b; 
    int c = b;                               
    cout << c << endl;                //输出结果为20
    return 0;
}

名字空间作用域：当不同的程序合并时，若出现重复函数，则分别才用不同的名字空间作用域予以区分
名字空间作用域的定义：  namespace + 作用域
名字空间作用域的访问： :: 全局作用域访问符        名字空间名称:: 名字空间作用域访问符
当名字空间作用域同名时：合并、当相同名字空间作用域存在相同变量时，报错、变量名重定义

using namespace std; 为C++的函数名字空间作用域 ，可采用std：：方式对名字空间作用域内的函数进行调用