c++note

 

================================================
第1天

1. 程序 = 数据(静态特性) + 算法(动态特性)。

2. 面向对象编程思想的3大特征：多态(Polymorphism),封装(Encapsulation),继承(Inheritance)
   对象
   类
   抽象
   继承性:继承重用现有类生成新类。
           超类:有其他类继承其行为的类。
        子类:继承其他类的类。
   封装:允许有选择地隐藏类中的属性和方法的过程。
   可重用性:
   多态性

3. C++中的保留字
    class                    //定义一个类

    friend                    //友元

    virtual
    inline
    private
    public
    protected
    const
    this
    new                        //调用构造函数(类似malloc),符号重载

    delete                    //调用析构函数(类似free)

    operator

4. C++和c语言的差异:
        (1) gcc 1.c                        //c语言编译

            g++ 1.cpp                    //c++编译

        (2) C++中可以在for语句中定义变量
        (3) C++中可以省略struct关键字
        (4) C++中定义变量时,可以用"()"初始化。如: int i(36);
        (5) C++中在堆中分配空间。如: int *p = new int;
            对应的销毁：delete p;
        (6) C++中在堆中分配23个int型空间。如: p = new int[23];
            对应的销毁：delete [] p;    //释放空间:默认调用析构函数

        (7) p = new int(25);            //可以分配的同时,给*p初始化

            printf("*p = %d\n", *p);
        (8) char ** c = new char * [10];    //给c一级分配char *类型的10个成员空间

            c[1] = new char[100];
            delete [] c[1];
            delete [] c;
        (9) 定义函数:c++的函数名可以重名(重载),只要形参的类型或个数不同即可
            函数名相同,形参类型和个数相同,但是返回值或函数内部实现不同,不能重载
        (10) c++可以在函数声明或实现时,给形参预置值,形参预置值必须从左往右,但是在函数的声明和定义时,只能有一个设置预置值
        (11) 内联函数:inline int max(int a, int b);        //在编译时展开,运行时存在内存中,形参为a++时a只加一次(没有函数的压栈,退栈的耗时操作,但是编译后代码量会增加)

             预处理:#define MAX(a, b) ((a) > (b) ? (a) : (b))
        (12) c++的函数可以直接传引用,用引用接收a和b,a不是实参的副本,而是a本身,定义类型时叫引用,'&'在'='右边为取地址符。
            定义一个引用,就是将引用右边的值,做一个标签(如：int &a = b;)
            '&'当在定义语句中并且在'='左边时才为引用,在'='右边和非定义语句的'='的左边为取地址符。
                void swap(int &a, int &b)
                {
                    int temp = a;
                    a = b;
                    b = temp;
                    *(a - 2) = 34567;    //错误

                    *(&a - 2) = 34567;    //可以改掉c

                }
        (13) c++中调用c语言编写的函数：
                extern "C" {        //表示当前文件调用test是用c语言的命名规则

                    extern int test(int, int);
                };
        (14) c中调用c++:
                g++ -c lib.o lib.cpp
                g++ -c temp.o temp.cpp
                g++ -fpic -shared -o libmy.so lib.o temp.o //将lib.o

                gcc 1.c -lmy -L .
                export LD_LIBRARY_PATH=.            //(1)将查找动态库的路径增加当前路径, (2)vim /etc/ld.so.conf


5. 增加动态库路径的方法：
    (1) export LD_LIBRARY_PATH=.            //在查找动态库的路径中增加当前路径

    (2) vim /etc/ld.so.conf                    //修改配置文件

    (3)    mv libmy.so /usr/include             //添加到默认动态库


6. 基本输入输出流：c++将输入和输出看作字节流
        #include <iostream>
        cin            标准输入流
        cout        标准输出流
        cerr        标准错误流(非缓冲)
        clog        标准错误流(缓冲)
        flush        刷新输出缓冲区
   格式化输出：
           width(),setw(int w)                设置输出的字段宽度(默认为0)
        fill()                            设置填充字符,默认是空格
        setiosflags::right,setiosflags::left        设置左右对齐
        setiosflags(ios::fixed);        用定点方式表示实数
        setiosflags(ios::scientific);    设置为指数
        precision(),setprecision(int d)    将精度位数设置为d,默认为6
        hex,oct,dec                        16进制,8进制,10进制
        write(char *, int);                输出字符串
        put(char c);                    输出字符
        read                            无格式读取一串字符
        get(var, 10, '\n')                输入字符超过10个只接收10个,小于10个的以'\n'为分隔
        getline
    -----------------------------------------------
    //#include

    //.h 98标准化以前的头文件, cout是ostream下的一个全局的对象。

    #include <iostream>            //98标准化之后的头文件,cout是std名字空间中的一个对象。

    using namespace std;        //设定全局的作用域(名字空间的作用域)

    //stdio.h    =>    98标准化后更改为cstdio

    std::cout << "hello world!\n";
    std::cout << "hello" << " world!" << std::endl;            //endl == \n

    -----------------------------------------------
    cout << 'a' << 'b' << 'c' << 'd' << endl;
    cout.put('a').put('b').put('c').put('d').put('\n');
    -----------------------------------------------
    cin.read(var, 9);                //只能接收8个,

    cout.write(var, 9);
    ----------------------------------------------
    cin.getline(var, 10, '\n');
    cin.get();                            //接收上面的超过10个后的空格

    ---------------------------------------------

7. c++的man手册存放路径：/usr/share/man/man3/

8. 类和对象
    类：定义数据的类型及操作这些数据的函数
    对象：类的实例
    成员：类中的变量和函数

    类不能在定义时,初始化
    类内部实现的方法,他会自动被转换成内联函数

    sizeof(对象)--是类中所有成员变量的大小,private,public遵循字节对齐

    成员名和方法名不能重名

    this是一个指针,指向对象本身

9. 对象的初始化：(构造函数和析构函数)
    构造函数的功能：在实例化对象时给对象分配内存空间,并可使用给定值来初始化对象
        构造函数可以重载
    拷贝初始化构造函数：利用一个已知的对象,实例化一个新的对象
    析构函数的功能：用来释放一个对象的已分配空间,并可在对象被清除前,完成一些清理工作。
        析构函数前加"~"号,并且不能有形参
    一个对象可以有多个构造函数
    构造函数名必须跟类名一样,并且没有返回类型
    默认构造函数是不带任何参数的构造函数


10.
    ----------------------------------
    void func(void) const                //const表示在函数func中不能修改值

    {
        a++;
    }
    ----------------------------------

11. 结构体和函数中局部变量的地址顺序：
    struct stu {
        int a;                //a在低地址

        int b;                //b在中地址

        char c;                //c在高地址

    };
    int main(void)
    {
        int a;                 //在栈的高地址

        int b;                //在栈的中地址

        char c;                //在栈的低地址

    }

=================================================
第2天

1. 操作符重载:把符号当作函数来使用
    | 流操作符:        <<    和    >>
    | 赋值操作符    =
    | 下标运算符    []

================================================
第3天
1. g + f         //跳到头文件

   ctl + o        //返回源文件


1. 继承






第4章    类与对象

=================================================
类的概念：
    |在现实中,类是一组客观对象的抽象,它将该组对象所具有的共同特征(包括属性和服务)封装起来,以说明该组对象的能力和性质。
    | 在系统中,类(class)是一种用户自定义的数据类型。通过类使得现实中的抽象实体在程序中直接表示为一个标识符,并可以进行引用和操作。

类的术语：
    | 对象：类的实例。
    | 成员：类中的变量和函数。

类中成员的公有和私有性：
    | private(私有部分)
        1.无法从类的外部访问私有数据
        2.其他类的私有数据对于当前类也是隐藏的
    | public(公有部分):构成类的接口(公有部分的成员可以被该类外部的函数访问)

类定义的格式：分为说明部分和实现部分
    1.说明部分：包括数据成员和成员函数(也称为"方法")的说明。
                成员函数是对数据成员进行操作的。
     格式：
             class 类类型名{
                    private:
                            私有成员说明
                    public:
                            公有成员说明
            };
     实例：
             class CPerson {
                    private:
                        char name[10];
                        int age;
                        char ***;
                    public:
                        void print();
            };
    2.实现部分：用来对成员函数进行定义。
     (1)类说明外部定义成员函数,注意需要使用作用域限定符::指明是哪个类中的成员函数。
          格式：
              函数返回类型 类名::成员函数名(参数表)
             {
                 函数体;
             }
         实例：
              void CPerson::print()
             {
                 cout << name << age << *** << endl;
             }
     (2)内联函数：语句只有1~5行,可以在类中定义(实现)成员函数,成为内联成员函数。
          实例：
             class CDate {
                public:
                    void Set(int m, int d, int y)        //设置日期值

                    {
                        month = m;
                        day = d;
                        year = y;
                    }
                    void Print();        //打印输出

                private:
                    int month;
                    int day;
                    int year;
            };

类定义的注意事项：
    | 1. 在类体中不允许对所定义的数据成员进行初始化。
    | 2. 类中数据成员的类型可以为任意的。
    | 3. 习惯上将类的定义代码放在头文件中。
    | 4. 成员名与方法名(函数名)不能重名。

==============================================

对象定义格式：
    | 定义了一个类只是定义了一种类型,它并不分配空间,不能进行操作。
    | 用类创建对象后,系统才为对象分配存储空间。
    | 类可以用sizeof()来求大小。
    | 对象定义格式：
         类类型名 对象名表;

对象成员的表示方法：
    | 通过对象可以访问类中的公有类型数据和成员函数。
            对象名.成员函数名;
            对象名.数据成员;
    | 通过指向类类型对象的指针访问类的公有数据成员和成员函数。
            指针名->数据成员;
            指针名->成员函数;
    | 注意：在成员函数中访问成员无须加对象名来作前缀

this指针：是一个对象指针,指向对象本身
        用于成员函数区分调用的成员来自哪个对象。
    CDate::Set(int m, int d, int y); <====> CDate::Set(CDate *this, int m, int d, int y);

new:动态创建对象,它在分配空间后,自动调用对象构造函数。
delete:显式销毁由new创建的对象。
    实例:
        int *ptr;
        ptr = new int[100];
        delete [] ptr;

==============================================
对象的初始化：

构造函数：
    1.功能：
        在创建对象时给对象分配内存空间,并可使用给定值来初始化对象。
    2.构造函数名必须跟类名一样,并且没有返回类型。
    3.默认构造函数是不带任何参数的构造函数。
    4.特点：
        (1)程序中不能直接调用构造函数,在创建对象时系统自动调用构造函数
        (2)构造函数可以重载。
        (3)构造函数有隐含的返回值,并由系统内部使用

析构函数：
    1.功能：
        释放一个对象的已分配空间。并可在对象被清除前,完成一些清理工作。
    2.在对象销毁时自动调用的成员函数
    3.编译器会生成对析构函数的调用
    4.与类同名,但是在函数名前有个波浪号(~)
    5.析构函数没有返回类型,也不带参数
    6.特点：
        (1)一个类中只能定义一个析构函数
        (2)析构函数可以被调用,也可系统调用
        (3)被自动调用的两种情况：
            i 在一个函数体内定义的对象,当函数结束时;
            ii 在new动态创建的一个对象,在使用delete释放时

    7.实例：
        class Cusername {
            public:
                ~Cusername();        //析构函数

        };

缺省构造函数和析构函数：
    1.在程序中定义一个对象而未指明初始化时
    2.在一个类中未定义析构函数时,编译系统也生成一个缺省析构函数

拷贝初始化构造函数:使用已存在的同类型的对象来初始化正在创建的对象。
    1.格式：
        类名::拷贝初始化构造函数名(类名&引用名);
    2.注意：每个类中必须有一个。
    3.被自动调用的三种情况：
     (1)是用一个已知对象初始化一个新对象时;
     (2)是以值调用方式向一个函数传递对象参数时;
     (3)当对象作为函数返回值时。
    4.原则：如果对象有动态分配空间,一定要手动编写拷贝构造函数,自己在里面重新作内存拷贝。

=================================================
类型的引用：
    在一个类型后面加入&表示对类型实例的应用。
    引用相对于原有类型的副本(和原对象的内容和地址完全相同)。

================================================
静态数据
    | 静态数据成员
    | 静态成员函数

静态数据成员：
    | c++的对象静态成员,为同一个类的所有对象共享。
    | 只在类的内部可见
    | 如果将静态成员声明为类的私有成员,则非成员函数不能访问它
    | 不是对象的一部分,没有this指针
    | 静态数据,不属于具体的对象