C++基本知识点

1. 命名空间:避免命名冲突    使用方式:    using namepace A;                A::a;

2.  static总结:        

修饰变量: 使局部变量的内存在全局区,(延长局部变量的生命周期)    

          使全局变量,不能在另外一个文件中使用extern 声明访问(缩小全局变量的作用范围)        

修饰函数: 使函数,不能在另外一个文件中使用extern 声明访问        

静态函数与变量:    静态函数中的变量,必须是静态的    

                   静态函数中的函数,必须是静态的        

c++中静态函数,静态变量属于类,可通过类名访问,也可通过对象访问                

类中,静态变量的初始化必须放在类外

注意:const与static同时修饰的变量:在类外进行初始化    

3,常对象,常函数:const    

  常对象调用常函数,   (this)    

  非常对象调用 非常函数,常函数    

  为什么常对象,不能调用非 常函数?   (非常函数的this指针)          

static 不能修饰 常函数 --  const 不能修饰静态函数    

非常对象,优先调用非常函数    

4常函数既可以被非常对象调用,又可以被常对象调用,那是不是全部都写常函数可保万无一失?              都写常函数,意味着,对象的属性就不可以自由改变了,              

  常函数中改变对象的属性值的方法,

  1,mutable修饰成员变量                                    

  2,const_cast<>(this)去除常属性        

2 当返回类型 是一个非常对象的引用的时候,只能用 非常函数了        

  常函数既可以被非常函数调用,又可以被常函数调用    

常函数调用非常函数,会出错  (参数 const this -> this 会出错)

4 const 想关见解:    

c语言中:使变量只读,不可修改(修饰指针,指针变量,一般变量)                  

可修饰参数,修饰返回值    

c++语言中:除了c中的特点,            

修饰对象            

使函数变成常函数(使this变成const)    

const修饰参数的目地:       

 1,使参数只读,不可修改(编译器提示性的限制)        

2,支持常对象作为参数(常对象不可隐式转成 非常对象)               

常对象做参数:传入的实参对象,既可以是常对象,有可以是非 常对象(隐式转换)            

非 常对象做参数:传入的实参对象,只能是非 常对象(则不支持常对象作实参)    

const可以优化效率        

const int a=10;        

cout<

5.对象创建与析构过程      

对象的创建:        

  1 为整个对象分配空间        

  2 构造基类部分(默认调用无参构造)  /或初始化列表构造       

  3 构造成员变量(初始化)           /或初始化列表构造        

  4 执行构造函数中的代码 (构造函数体{}中,不是成员变量初始化的地方)    

析构:1 执行析构函数中的代码          

     2 销毁(析构)成员变量          

     3 析构基类部分    

6.必须使用初始化列表的情况  

    1const 成员变量

    2引用类型的变量 

    3继承关系的类，想以有参构造函数构造基类的时候 

   注意:const与static同时修饰的变量:在类外进行初始化

7.必须显示 使用this的情况    

  1形式参数,和成员变量名字相同时,(形式参数会隐藏成员变量)    

  2想在常函数中,对成员变量重新赋值时(去掉this的const属性)    

  3在类中的成员函数中想返回尚未创建的对象或对象的指针时    

  4在类中,把尚未创建对象作为参数,传给另一个函数 (教师,学生类间的信息通信)    

8.this的类型,和实际指向的对象没关系,和当前this所在的类有关    

    class A{        

        void foo(){            

            bar();//this.bar();编译时,静态绑定本类的bar函数        

        }        

        void bar(){}    

    }    

    class B:public A{        

        void bar(){}    

    }  

    int main(){ 

     A a=new B;    

     a.foo();

    }

9.动态绑定:(运行时绑定)    

     A   

     B:A    

     A* a = new B;   

     虚函数表的指针,存在B对象中 (虚函数,对象的类型信息等)        

优点:多态,动态绑定,基类指向子类,相同的调用,根据实际对象的不同,可以灵活执行不同的动作。                                        (相同的行为,不同的表现)

缺点:(多占内存,速度降低)    

虚函表的指针,指向的一系列 虚函数数组  (多占内存)    

执行是动态绑定,多了一些步骤(确认类型,匹配虚函数,找地址)    

虚函数,不能内联,由于编译期不绑定具体函数 (不能内联优化速度)

使用建议:(是否需要虚函数,是否需要写继承)    

要使用多态效果的时候,考虑虚函数,其他的不考虑    

使用多态效果的时候,考虑继承,其他的使用组合关系    

10.面向对象的三大特征   

 封装:私有对象的属性,不让外界直接访问(对象可以在类内部直接访问私有属性)                 protect/public 友元函数/友元类 (只是能让类外的对象访问类的私有属性)    

  继承:可以使用父类的属性和方法    

  多态(重写):基类指向不同的子对象,相同的行为,会有不同的表现(实际子对象的表现)    

重写/覆盖:override(父子类-不同作用域)    

重载:overload(同一作用域)    

隐藏:(不同作用域)

12,缺省参数    

注意事项:重载匹配时,如果既可以调用缺省函数,又可以调用一个非缺省的函数,就引起编译错误        

13,时间函数    

time_t time(time_t* t)//参数为0,可获得一个秒数(系统时间-1970-1-1 0:0:0)    

struct tm* localtime(const time_t*)//可以获得时间结构体        

tm_year=(系统时间的年-1900)//        

tm_month=(系统时间的月+1)

14,单例模式    

饿汉式,懒汉式

饿汉式:类加载时,直接构造了一个静态栈对象,每次调用静态函数时,都返回这个静态对象的引用

懒汉式:类加载时,只构造了一个静态指针,当需要创建一个对象时,  才调用一个静态函数创建一个对象,也返回这个对象的引用, 以后再调用这个静态函数,就不再创建新对象,只返回第一个对象的引用    

懒汉式存在线程安全问题

15异常:    try{}catch(exception ){}多层catch时,子类要放在基类的前面发生异常时,跳到有花括号{,会自动调用catch到的异常类的析构函数

16 钻石继承:     A                       

                B   C                          

                  D    

B:virtual public A虚表:当前地址的偏移地址和虚函数表:

17    构造函数:创建新对象        

拷贝构造:根据旧对象,创建新对象       

拷贝赋值:用一个对象,给另一个对象赋值

18 参数传递方式比较:引用,指针,值传递        

引用,指针 vs 值传递:        

    引用和指针不会建立建立对象的副本,不会引起拷贝构造出一个新对象,        

引用vs指针    

    引用比指针使用方便,    

    运算符重载的时候,返回引用比返回指针,书写的形式上更加流畅。