01_C与c++的区别

一、命名空间

1. ①．标准命名空间

namespace chen{     } ;

1. ②．匿名命名空间

namespace {     } ; /*可以直接调用空间中的函数与变量*/

1. ③．命名空间的别名（空间名特长）

namespace chenafafasfdasdfasfsdf{       } ;
namespace run = chenafafasfdasdfasfsdf ; 

1. ④．命名空间嵌套

namespace chen{ 
    Namespace wei{
        Int a(10) ;
    };
} ;
Chen::wei::a ;

1. ⑤．命名空间拓展（软件的迭代式开发）
   （不能利用别名）直接写就能拓展了。
2. ⑥．注意：
   
   • 1、命名空间不要实现函数，可以申明类，或是指针函数。
   • 2、命名空间中的内容（类、对象、函数、变量）都是公有的。
   • 3、类是结构体，结构体也有私有，结构体默认都是公有。
   • 4、命名空间的别名不能用于拓展命名空间。

二、类型初始化

1. Int a(45) , c++初始化标准

三、函数重载

1. ①．空

四、泛型auto（只能用于栈）

1. ①．自动变量，自动获取类型，输出，泛型
   auto a = 10.6 ;(自动变量，自动匹配类型)
2. ②．自动变量，可以实现自动循环一维数组

int  a[10]  =  { 55,66,22,44,66,99,44,55,11,77} 
        for( auto data : a ){  /*泛型c++语法,循环一维数组*/
            cout<<data<<endl ;
        }

1. ．自动循环的时候，对应的必须是常量（例如上面的a是指针常量）

五、左值与右值引用

1. ①．左值引用（是用指针实现的，实际是操作一个地址改变一个变量）

int num = 10 ;
int &a = num ;//(是变量的别名，操作同个地址空间)
Int *pnum = &num ;//(这是取地址)
Int * & rpnum = pnum ;//(指针引用，指针的引用，指针的别名)

1. ②．右值引用（优化内存，？？）

    int num = 10 ;
    int * && a = &num ;
    int *p = a ;

1. ③．例子 : 引用的本体不在，其别名也就失去了作用。

int * & get( void ){
    int *p = new int(110) ;
    int * & a = p ;
    return a ;
}
int main( int argc , char** argv ) {

    int * & p = get() ;
    /*别名的本体不在，别名也就没用了，成为野指针*/
    cout<<*p<<endl ;
    cout<<p<<endl ;
    /*所以这里输出不确定的值，但是在堆中申请的内存空间依旧
存在，只是链接不在了*/
    cout<<*p<<endl ;

    system("pause") ;
    return 0 ;
}
/*
*解决，这里必须将返回的指针地址，重新在栈中申请内存放入刚传回来的地址。
*Int *rp = p 或是 int * p = get() ;
*/

六、Const关键字说明

1. ①．与c的区别，在c中下面a[num]是不予许的

    const int num(5) ;
    int a[num] = { 11,22,33,44,55 };
    for( auto data : a){
        cout<<data<<endl ;
    }

1. ②．强制类型转换

    const int num(5) ;
    int * p = (int *)&num ;
    /*通过强转实现类型转化，编译器可以通过，但是num的值不会改变（符号常量表）*/
    *p = 15 ; 
    cout<<num<<endl ;

1. ③．强制去掉const属性

    const int num(5) ;
   /*强制去掉const属性*/
    int * p = const_cast<int*>(&num) ; 
    *p = 15 ;
    cout<<num<<endl ;

1. ④．const int * p ( int const *p) 指针指向的内容不能改
2. ⑤．int * const p ; 指针的值不能改
3. ⑥．const int *const p ; 指针的值与指针指向的内容都不可以改
4. ⑦．const传参引用

int get( const int & a ){

    int * p = const_cast<int *>( &a ) ;
    *p = 5 ;
    return a ;
}
int main( int argc , char** argv ) {

    const int age0 = 10 ;
    int age1 = 50 ;

    cout<< get(age0)<<"--"<< age0 <<endl ;//5--10

    cout<< get(age1) <<"--"<<age1<< endl ;//5--50，奇怪，为什么这里改不了呢？答：别急，看下个输出。

    cout<<age0<<"--"<<age1<<endl ; //10--5,这里就好了，这跟编译器有关，是语句的压栈出栈行为导致的。

    /*看这里的输出，你会觉得奇怪。这跟c++的符号常量表有关*/
    int *p = const_cast<int*>(age0) ;
    cout<<age0<<"---"<<*p<<endl ;//10---5

    system("pause") ;

    return 0 ;
}
/*
注意：如果传递进去的是变量，经过形参const修饰后，在函数内部还是可以通过强转或是消除const属性来改变传入进去的变量的值的。
如果传入进去的是const常量，即使在函数内部强转或是消除const属性，编译器能编译通过，但是改变不了常量的值。
*/

七、堆栈new & delete(有误)

1. ①．栈 ：
   int a = 2 ;
2. ②．堆 ：
   int* p = new int ; delete(只能释放一次)
   int* p = new int[10] ; delete []p ;(一维数组)
   Int* p = new int[80] ; int (pr)[10] = (int ()[10])p ;(二维数组)（注：c++中没直接创建二维数组的能力）