C++学习一

一.兼容和差异1.引用2.函数重载1)概念3.函数默认参数4.结构体5.名字空间6.变量的链接性7.函数的链接性8.动态内存1)new/delete运算符2)new [] /delete []运算符
二.输入输出流1.功能2.cout 输出流对象
三、类和对象1.OOP思想的三大特征2.类和对象1)类2)对象3.语法权限说明:4.构造函数
5.析构函数6.构造函数和析构函数的顺序7.this指针8.拷贝构造函数

一.兼容和差异

1.引用

    对变量取别名；

    eg：

        int a = 123;

        int &b = a;

2.函数重载

    1)概念

        同一个作用域中定义多个同名的函数，函数的参数不同(个数 类型  个数和类型都不同)

        eg:

            int add(int a)

            {

           

                return a+a;

            }

           

            int add(int a, int b)

            {

                return a+b;

            }

           

            char add(char x, char y, char z)

            {

                return x+y+z;

            }

3.函数默认参数

    指：可以给函数的形参指定默认值；

    eg:

            int add(int a)

            {

           

                return a+a;

            }

           

            int add(int a=10, int b=20)

            {

                return a+b;

            }

        注意：

            int main()

            {

                add(123);//歧义

                add(123,333);

           

                return 0;

            }

4.结构体

    struct 结构体名{

    private:

        成员变量;

    public:

        成员函数;

  };

 eg:

        struct Demo{

        public:

            void setx(int val)

            {

                x = val;

            }

           

            int getx();

       

        private:

            int x;

        };

        int Demo::getx()

        {

        return x;

        } 

        int main()

        {

            struct Demo obj;

            obj.x = 123;//error private成员只能通过成员函数访问

            obj.setx(321);

            cout << obj.getx() << endl;

            return 0;

        }

5.名字空间

    变量、函数、类

    namespace 名称{

        变量

        函数

        类

    }    eg:       

 namespace A{

              int i = 123;

            void prnmsg()

            {

                printf("i=%d\n",i);

            }

        };

int main()

{

        #if 0

            A::i = 321;

            A::prnmsg();

        #else

            using namespace A;

            i = 321;

            prnmsg();

        #endif

            return 0;

        }

       

6.变量的链接性

    auto:        空链接

    register:    空链接

    全局变量:     外部链接

    static全局：  内部链接

    static局部：  空链接

7.函数的链接性

    外部链接：

    内部链接：static静态函数

8.动态内存

    1)new/delete运算符

        eg:

            int *p = new int;

            *p = 123;

            delete p;

    2)new [] /delete []运算符

        eg:

            char *p = new char [64];

            strcpy(p,"hello world");

            delete [] p;    

二.输入输出流

1.功能

    c++中，输入和输出主要用于调试

2.cout 输出流对象

    #include <iostream>

    using namespace std; 

    int main()

    {

        cout << "hello world" << endl;

        cout << "hello";

        cout << '\n;

        return 0;

    }

三、类和对象

1.OOP思想的三大特征

    封装:代码模块化

    继承:代码重用

    多态:接口重用

2.类和对象

    1)类

        是一种自定义数据类型

        是对象的类型

        不占用内存空间

        描述对象共有的属性和行为

    2)对象

        是类类型的变量

        占用内存空间

3.语法

    class 类名{

    private://私有成员

        成员变量或方法

    public://公有成员

        成员变量或方法

    protected://保护成员

        成员变量或方法

    };

    权限说明:

        public:在类的外部通过类对象直接访问

        private:只能在类内部访问，即通过成员方法访问

        protected:在类或者子类内部访问

        默认权限:private

    eg1:

        //定义Demo类

        class Demo{

        public:

            void setval(int v)

            {

                val = v;

            }

           

            int getval(void)

            {

                return val;

            }

        private:

            int val;//成员变量

        };

       

        int main()

        {

            Demo obj; //定义类对象

            obj.setval(123);//类对象访问public成员

            cout << obj.getval() << endl;

       

            return 0;

        }  

    eg2:对象指针

4.构造函数

    class 类名{

    public://公有成员

        类名(参数列表) //构造函数

        {

        }

        成员变量或方法

    private://私有成员

        成员变量或方法

    protected://保护成员

        成员变量或方法

    };

    eg1:

        //定义Demo类

        class Demo{

        public:

            Demo(int v = 0) //构造函数

            {

                cout << __func__ << ":" << __LINE__ << endl;

            }

       

            void setval(int v)

            {

                val = v;

            }

            int getval(void)

            {

                return val;

            }

        private:

            int val;//成员变量

        };

       

        int main()

        {

            Demo obj; //定义类对象

            obj.setval(123);//类对象访问public成员

            cout << obj.getval() << endl;

            return 0;

        }

    eg2:构造函数传参

        //定义Demo类       

 class Demo{

            public:

                Demo(int v=0) //

                {

                    cout << __func__ << ":" << __LINE__ << endl;



                }



                int getval(void)

                {

                    return val;

                }

                void setval(int v)

                {

                    val = v;

                }



            private:

                int val;//成员变量

        };



        int main()

        {

            Demo obj(666); //构造函数传参

            cout << sizeof(obj) << endl;




            //obj.setval(123);//

            cout << obj.getval() << endl;//类对象访问public成员



            return 0;

        }

        eg3:初始化列表

        //定义Demo类       

class Demo{

            public:

                Demo(int v=0) : val(v)   //初始化列表：初始化  val=v

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

                int getval(void)

                {

                    return val;

                }

                void setval(int v)

                {

                    val = v;

                }



            private:

                int val;//成员变量

        };



        int main()

        {

            Demo obj(666); //构造函数传参

            cout << obj.getval() << endl;//类对象访问public成员



            return 0;

        }

       

   注意：

    若没有定义构造函数，系统提供默认的构造函数；

   

 5.析构函数

    特殊的成员函数

    功能:回收清理工作 特点：~类名 无返回值 无参数 不可重载 对象结束时自动调用，可手动调用

   

    eg:

        //定义Demo类

        class Demo{

            public:

                Demo(int v=0) //构造函数:  功能:对象初始化 特点:函数名和类名同名 无返回值 参数可有可无 可重载 构造对象时自动调用 不可手动调用

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

                ~Demo()//析构函数：对象结束时自动调用

                {

                    cout << __func__ << ":" << __LINE__ << endl;

                }

                int getval(void)

                {

                    return val;

                }

                void setval(int v)

                {

                    val = v;

                }

            private:

                int val;//成员变量

        };

        int main()

        {

            Demo obj(666); //定义类对象 自动调用构造函数

            cout << sizeof(obj) << endl;

            //obj.Demo();//error: 手动调用构造函数

            obj.setval(123);//

            cout << obj.getval() << endl;//类对象访问public成员

            return 0;

        }

       

        注意：

            若没有定义析构函数，则系统提供默认的析构

6.构造函数和析构函数的顺序

    构造顺序:先定义的先构造

    析构顺序:取决于生命周期  同生命周期时：先构造的后析构 后构造的先析构

    eg:

        //定义Demo类       

 class Demo{

            public:

                Demo(int v=0) //构造函数:  功能:对象初始化 特点:无返回值 参数可有可无 可重载 构造对象时自动调用 不可手动调用

                {

                    cout << __func__ << ":" << __LINE__ << this << endl;



                }

                ~Demo()//析构函数

                {

                    cout << __func__ << ":" << __LINE__ <<  this << endl;



                }

                int getval(void)

                {

                    return this->val;

                }

                void setval(int v)

                {

                    this->val = v;

                }



            private:

                int val;//成员变量

        };



        Demo obj1;

        int main()

        {

            Demo obj(666); //定义类对象 自动调用构造函数

            Demo *p = new Demo(888);//堆区对象



            static Demo obj2;



            //构造顺序: obj1 -> obj -> *p  -> obj2

            //析构顺序: *p -> obj -> obj2  -> obj1



            cout << &obj1 << " " << &obj << " " << p << " " << &obj2 << endl;



            delete p;



            return 0;

        }

7.this指针

    对象的内部指针，只能在类内部使用

   

8.拷贝构造函数

    功能：用一个对象够早另外一个对象时调用拷贝构造函数

    形式：

        类名(对象的引用)

        {

       

        }

    注意：

        当没有定义拷贝构造函数时，系统提供默认的拷贝构造

    eg1:       

 class Demo{

        public:

            Demo(int v=0):val(v) //构造函数:  功能:对象初始化 特点:无返回值 参数可有可无 可重载 构造对象时自动调用 不可手动调用

            {

                cout << __func__ << ":" << __LINE__ << endl;



            }



            Demo(Demo &obj2)//拷贝构造函数

            {

                this->val = obj2.val;

                cout << __func__ << ":" << __LINE__ << endl;



            }



            ~Demo()//析构函数

            {

                cout << __func__ << ":" << __LINE__ << endl;



            }




            int getval(void)

            {

                return val;

            }

            void setval(int v)

            {

                val = v;

            }





        private:

            int val;//成员变量

    };



    int main()

    {

        Demo obj(666); //定义类对象 自动调用构造函数



        Demo obj1(obj);//等价：Demo obj1 = obj;



        cout << obj.getval() << endl;//类对象访问public成员

        cout << obj1.getval() << endl;//类对象访问public成员



        return 0;

    }