C++基础

1：C++（cpp）是c语言的超集：包含了很多c语言的特性c++是在c语言上扩展而成。

        c++的源程序后缀：.cpp         其中包含一些小众的后缀名：.C         .cc        .c++        .cxx

强制类型转换

c语言：int a = （int）55.5；

c++：   int a = int（55.5）；

 const特性

c语言：        const int a = 10；    a变成只读变量

c++   ：        const int a = 10；   a是一个常量

因为c++中没有定常量类型容易出现安全问题，所有在c++中很少用宏定义，都用const来定义常量

 inline内联函数

c语言中：

#define MAX（A,B）             （A> B?A:B）

优点：执行速度快。

缺点：①如果使用的地方多，每个地方都要展开，造成代码体积增加

           ②用法复杂，容易出错

           ③没有指定类型，没法做类型检查

c++语言中：

inline int max(int a , int b) {a>b?a:b;}

 函数引用

int i;

int &ii = i;        //相当于给i取别名为ii

引用的作用：

c语言中，形参改变无法影响实参，解决方法——指针传递

        int a,int b;

        void  sqap(int aa,int bb)

                {

                        交换aa，bb并不会影响外面的值

                        原因：函数的参数是函数的局部空间，只作用于函数内部。

                }

        swap(a,b)

c++引用传参

        int aa=55,b=66;

        void swap(int &aa,int &bb)

        {

                int tmp = aa;

                aa = bb;

                bb = tmp;

        }

        swap(aa,bb);

        cout<<"aa="<<aa<<"bb="<<bb<<endl;

函数返回值

 如何正确调用函数返回值：

int   g_ver;

        int & add（int aa，int bb）

{

        g_ver = aa+bb；

        return g_ver；

}

add（55，66）；

int c = add（55，66）；    //定义了一个新的变量c存储返回值

int &c = g_ver；                  //定义了一个别名所指向的就是g_ver空间

add（55，66） = 100；     //此时给g_ver从新赋值为100

cout<<"g_ver="<<g_ver<<endl;

函数参数默认值

int add（int a,int b）       int add(int a,int b=20)            int add(int a,int b=20) 

{

return(a*b);

}

add(10,20)                        add(10)                                add();

这三类对等，！！！函数参数的默认值必须从右到左依次赋值，为避免歧义，传参的时候就固定把有固定值的放到最右边

函数重载

允许函数重命名：会根据传递的参数个数，类型和顺序有关系

 内存分配

c语言：用malloc分配堆空间，free（）用于释放空间

c++：new                                delete

        int *p = new int  ;        //创建

        delete p;                     //释放

        int *p = new int [8];         

        delete []p ;

命名空间：namespace

如果自己的局部和全局变量重名了

        格式：using namespace （+自己定义的名字）

1：使用自己的局部变量直接使用变量就行，但要使用自己的全局变量（得加：：）

 #面向对象的思想

对象：凡是占据空间的事物，都可以称之为对象；

类：不占据物理空间的类，比如人对一类事物的总结：思想，抽象，知识

对象的构成：

        静态属性：姓名，年龄，性别

        动态属性：吃喝拉撒，动态的

class cat{

        public：                                   //把类定义为公开的

        //静态的属性

        string name [32];

        int age;

        string sex[20];

        //动态的方法

        void run ()  ；

        int  eat （）；

};

        void run()

        {cout<<"cat run"<<endl}

构造函数 ： structrue

        1.与类同名

        2.没有返回值，void也不行，用于区分普通函数区分

        3.构造函数对对象产生的时候自动执行

        4.构造函数可以重载（可以有很多个）

        5.如果不屑构造函数的参数，系统会默认给加上一个默认构造函数（）{}

拷贝构造函数

cat (){

        int age;

        shring name;

}

cat one();

cat two(one);

 析构

当对象被释放的时候，我们需要对它进行去初始化

创建的时候就会自动触发，当构造函数得空间被结束就会自动释放掉空间（格式单一，固定格式）

~cat（）{

}