C++基础知识总结

1、类和struct的区别
用class和struct关键字定义类的唯一差别在于默认访问权限：默认情况下，struct的成员为public（因此可以省略public关键字），而class的成员为private。


2、在C++中
每当函数返回时，都会清理栈。局部变量和函数参数存放在栈中。
只有到程序结束时候才会清理堆（java中自动清理），所以使用完堆内存时，程序员需要负责将其释放。如果在函数中预留堆中的内存，在函数返回后，该内存仍可用。当使用new关键字时候，程序会返回一个地址，因此只能用指针类型接收。注意用完之后要手动delete掉。


3、导致内存泄露的另一种情形是，没有释放指针指向的内存就直接给它重新赋值（重新new）


4、Teacher是一个类，
Teacherｔ(name);//在栈中创建了一个对象
Teacher *t = new Teacher (name);//在堆中创建了一个对象
对于在栈中创建的Teacher对象，使用句点运算符（.）来访问其成员数据和成员函数；要访问对中的Teacher对象，必须对指针解引，并对指针指向的对象使用句点运算符。如（*t）.XXX。鉴于比较繁琐，c++提供一种指向运算符（->），可以直接写为t->XXX


5、
具体地说如果出现以下几种情况，程序就会执行析构函数：
①如果在一个函数中定义了一个对象(它是自动局部对象)，当这个函数被调用结束时，对象应该释放，在对象释放前自动执行析构函数。
②static局部对象在函数调用结束时对象并不释放，因此也不调用析构函数，只在main函数结束或调用exit函数结束程序时，才调用static局部对象的析构函数。
③如果定义了一个全局对象，则在程序的流程离开其作用域时(如main函数结束或调用exit函数) 时，调用该全局对象的析构函数。
④如果用new运算符动态地建立了一个对象，当用delete运算符释放该对象时，先调用该对象的析构函数。

6、c++中this指针，用->来指向对象。无需为创建和删除this指针操心，编译器负责这项工作。


7、const指针
const int * pOne；//pOne是指向整型常量的指针，不能修改指向的值
int * const pTwo ;//pTwo是指向整型的常量指针，不能修改指针的指向。
const int * const pThree； //pThree是一个指向整型常量的常量指针。


8、创建引用时，使用另一对象的名称来初始化它，对引用执行的任何操作实际上针对的就是目标。引用即对象的别名，在内存中没有地址，也不占用空间，引用一旦初始化就不能修改。


9、c++中按值传递和按引用传递
按值传递：安全，备份的修改不会更改原值
按引用传递：引用不创建备份，效率高，但会改变原值


10、不要返回不在作用域内的引用。引用始终是一个实际存在对象的别名，如果它指向的是空对像，那么程序是非法的。


11、不能对引用进行delete，因此函数的返回值如果为堆对象，且让引用接收，那么就无法回收对象。这样只能将引用再赋给指针来delete。


12、可以重载构造函数，但不能重载析构函数。析构函数的签名总是这样：名称为类名加~，且不接受任何参数。


13、一种特殊的写法，构造函数初始化默认参数（红色部分）：
#include<iostream>
class Test
{
private :
    int a;
    int b;
public:
    Test():
      a(1),b(2)
      {

      }
    Test(int a,int b)
    {
        this->a=a;
        this->b=b;
    }
    int getA()
    {
        return this->a;
    }
    int getB()
    {
        return this->b;
    }
};




14、拷贝构造函数
所有的拷贝构造函数都接受一个参数：指向类的引用。最好将该引用声明为常量，因为拷贝构造函数不能修改传入的对象。


15、不能对非NULL的指针进行delete，会报错。


16、如果未提供自己的拷贝构造函数，则C++提供一个默认拷贝构造函数，就像没有提供构造函数时，提供默认构造函数一样。
若用户没有定义拷贝构造函数,则编译器自动添加默认拷贝构造函数，称为浅拷贝。它只能完成基本类型数据类型(如int型变量)的拷贝，若类中有动态数组等数据类型， 浅拷贝就会出问题。即是说，浅拷贝有潜在危险(当类的数据成员都是基本类型数据类型时，它是安全的)。因此，在任何情况下，用户自定义拷贝构造函数是可取的。
出现指针成员变量的类中一定要自己写拷贝构造函数


17、成员方法加const表示该方法不会修改类成员。以下会报错：
void alterB() const
{
    this -> b = this -> b + 1;
}




18、运算符重载的格式如下
returnType operatorsymbol (parameter list)
{

}
//如对类Count的++(前缀)的重载
Count& operator++ ()
{
    ++value;
    return *this;
}
//后缀++
Count operator++ (int)
{
    Count tmp (*this);
    ++value;
    return tmp;
}
//加法运算符+
Count operator+ (Count& c)
{
    return Count(this->value+c.value);
} 
main()
{
    Count c1,c2,c3;
    c3=c1+c2;//这句话其实理解为c3=c1.operator+ (c2);即成员函数调用
}




19、复制运算符
例如：
Count c1(1);
Count c2(2);
c1 = c2;//此处不会调用拷贝构造函数，因为c1已经存在。

上述赋值语句处会调用类中提供的默认赋值运算符。类中不仅提供了默认构造函数，默认析构函数，默认拷贝构造函数，还提供了默认复制运算符。
默认复制运算符与默认拷贝构造都有浅复制和深复制，浅复制只复制成员，导致两个对象执行同一个堆中区域。深复制则会分配内存。
可以重写复制运算符。假设类Count中有一个名为value的int指针
Count operator= (const Count& t)
{
    if(this==t)
        return this;
    delete this -> value;
    value = new int ;
    *value = t.getValue();
    return *this;
}



20、转换运算符
（1）内置类型变量赋值给一个用户定义类型对象
int i = 0;
Count t = i;

只需要在Count类中提供一个带int 参数的构造方法即可
（2）用户定义类型对象赋值给内置类变量
Count t (2) ;
int i = t;

需要在Count类中指定转换运算符，如下(下划线部分)：
class Count
{
public:
    Count(int value){this->value=value;}
    operator unsigned int(){return value;}
private:
    int value;
}



21、继承
class Parent
{
    public:
            Parent(int value){this->value=value;}
    private:
            int value;
};
class Child : public Parent
{
    public:
            Child(int value):
            Parent(value),
            c('0')//不能将父类parent的value属性这样初始化。value初始化只能如上句调用父类构造函数、或者在下面的函数体内初始化
            {}
    private:
            char c;
};



22、隐藏
在c++中，如果子类隐藏了父类的函数，则父类中的所有同名函数都会被隐藏！！！
#include<iostream>
class Parent
{
public:
    Parent(){}
    Parent(int value){this->value=value;}
    ~Parent(){}
    Parent(Parent&){}
    void move(){std::cout<<"Parent moves "<<value<<" step!"<<std::endl;}
    void move(int n){std::cout<<"Parent moves "<<n<<" step!"<<std::endl;}

protected:
    int value;
};
class Child: public Parent
{
public:
    Child(){}
    Child(int value,int special):
    Parent(value),
    special(special)
    {

    }
    void move(){std::cout<<"Child moves "<<value<<" step!"<<std::endl;}
private:
    int special;
};
void main()
{
    Child *c=new Child(2,3);
    c->move(2);//error！！！因为父类中所有名字为move的函数都已经被隐藏，子类已经没有move(int)方法，但可以用父类调用
    Parent *p;
    p->move(3);//right！！！

}




在java中，如果子类隐藏了父类的函数，则父类中的其他同名函数不会被隐藏！！！下面是java代码
public class Parent {
    protected int value;
    public Parent() {
    }
    Parent(int value) {
        this.value = value;
    }
    public void move() {
        System.out.println("parent moves " + value + " steps!");
    }
    public void move(int n) {
        System.out.println("parent moves " + n + " steps!");
    }
}
public class Child extends Parent {
    Child() {
        super();
    }
    Child(int value) {
        super(value);
    }
    public void move() {
        System.out.println("child moves " + value + " steps!");
    }
    public static void main(String[] args) {
        Child child=new Child(1);
        child.move(2);//right！！！
    }
}



23、多态
要实现多态，就要声明为虚函数virtual，这与java是有区别的（java不需要声明virtual）。
class Parent
{
    public:
            Parent(int value){this->value=value;}
            virtual void function(){}
    private:
            int value;
};
class Child : public Parent
{
    public:
            Child(int value):
            Parent(value),
            c('0')//不能将父类parent的value属性这样初始化。value只能如上句，或者在下面的函数体内初始化
            {}
            void function(){std::cout<<"test"<<std::endl;}
    private:
            char c;
};






24、在多态的使用中，只有通过指针和引用进行调用时，才能发挥虚函数的魔力；按值传递对象时不能发挥虚函数魔力。按值传递只能够保留父类的方法，切除子类特有方法。
#include<iostream>
class Parent
{
public:
    Parent(){}
    Parent(int value){this->value=value;}
    ~Parent(){}
    Parent(Parent&){}
    virtual void move(int n){std::cout<<"Parent moves "<<n<<" step!"<<std::endl;}
protected:
    int value;
};
class Child: public Parent
{
public:
    Child(){}
    Child(int value,int special):
    Parent(value),
    special(special)
    {

    }
    void move(int n){std::cout<<"Child moves "<<n<<" step!"<<std::endl;}
private:
    int special;
};
void main()
{
    Parent *p = new Child(1,1);
    p->move(1);//输出child moves 1 step！
    Parent& p1 = *p;
    p1.move(1);//输出child moves 1 step！
    Parent p2 = *p;
    p2.move(1);//输出Parent moves 1 step！，即子类的方法被切除，调用父类方法
    delete p;
}




25、 如果将基类指针赋给子类，就用到了dynamic_cast，它确保转换是安全的。在运行阶段检查基类指针，如果可以转换，就转化为子类指针，如果不能，子类指针为空NULL。


26、C++中用纯虚函数来支持抽象数据类型ADT，抽象类和函数。java中用abstract关键字。
任何包含一个或多个纯虚函数的类都是ADT，不能对其实例化，试图这样做将导致编译错误。
a、不能创建这个类的对象，只能从其派生
b、务必重写从这个类继承的纯虚函数
#include<iostream>
class Parent
{
public:
    Parent(){}
    Parent(int value){this->value=value;}
    ~Parent(){std::cout<<"destructor"<<std::endl;}
    Parent(Parent&){}
    virtual void move()=0;
protected:
    int value;
};
class Child: public Parent
{
public:
    Child(){}
    Child(int value,int special):
    Parent(value),
    special(special)
    {

    }
    void move(){std::cout<<"Child moves "<<value<<" step!"<<std::endl;}
private:
    int special;
};
void main()
{
    Parent *p = new Parent(1);//error!!!，不能创建ADT的对象
    Child *c = new Child(1,1);//子类实现了纯虚函数，可以创建对象
    c->move();
}

嬠/size]
27、不要忘记给静态成员变量赋初值。不像java，变量可以直接在类中声明处赋值，c++中的变量赋值不能在类中声明处赋初值
#include<iostream>
class Parent
{
public:
    Parent(){}
    Parent(int value){this->value=value;}
    ~Parent(){}
    Parent(Parent&){}
    int value;
    static int num;
};
int Parent::num=0;



28、要将私有成员或函数暴露给另一个类，必须将其声明为友元类，友元关系不能传递，不能继承，也不可交换，将Class1声明为Class2的友元并不能让Class2成为Class1的友元。有时候不想将友元访问权限赋予整个类，为此，可以将成员函数而不是整个类声明为友元。
友元函数：友元函数的声明可以放在类的私有部分，也可以放在公有部分，它们是没有区别的，都说明是该类的一个友元函数
#include<iostream>
class Parent
{
public:
    Parent(){}
    Parent(int value){this->value=value;}
    ~Parent(){}
    Parent(Parent&){}
    friend void getValue(Parent& p);
private:
    int value;
};
void getValue(Parent& p)//不需要加Parent::,因为友元函数不属于该类
{
    std::cout<< p.value<<std::endl;
}
void main()
{
  Parent p(2);
  getValue(p);//友元函数不属于类，直接调用，无需对象表示
}


友元类：一个类能够作另一个类的友元。当一个类作为另一个类的友元时，这就意味着这个类的任何成员函数都是另一个类的友元函数。
以下语句说明类B是类A的友元类：
#include<iostream>
class A
{
public:
    A(){}
    A(int value){this->value=value;}
    ~A(){}
    A(A&){}
    friend class B;
private:
    int value;
};
class B
{
public:
    B(){}
    ~B(){}
    B(B&){}
    void getValue(A& a)
    {
        std::cout<<a.value<<std::endl;
    }
};
void main()
{
    A a(2);
    B b;
    b.getValue(a);
}

经过以上说明后，类B的所有成员函数都是类A的友元函数，能存取类A的私有成员和保护成员。



29、函数指针
可以声明指向函数的指针，其实函数名就是指向函数的常量指针，就像数组名是指向数组第一个元素的常量指针一样。
#include<iostream>

void add(int a, int b)
{
    std::cout<< a+b <<std::endl;
}
void subtract(int a, int b)
{
    std::cout<< a-b <<std::endl;
}

void main()
{
    void (*pFunc) (int, int);
    pFunc=add;//给函数指针赋值，使其指向add函数
    pFunc(2,1);//赋值之后调用
    pFunc=subtract;
    pFunc(2,1);
}




30、将函数指针作为参数传递
#include<iostream>

void add(int a, int b)
{
    std::cout<< a+b <<std::endl;
}
void subtract(int a, int b)
{
    std::cout<< a-b <<std::endl;
}
void printValue(void (*func)(int, int) , int a, int b)//函数指针作为参数
{
    func(a,b);
}
void main()
{
    void (*pFunc) (int, int);//函数指针声明
    pFunc=add;//函数指针赋值
    printValue(pFunc,2,1);//函数指针作为参数传递
    pFunc=subtract;
    printValue(pFunc,2,1);
}



31、空指针常量：使用指针时候一定要给它赋值，，未初始化的指针可能指向内存的任何位置，这就做野指针。为了避免这种威胁，创建时候应该将空值（0或者NULL）赋给指针。但这会在函数重载的时候造成一定麻烦，比如一个接收字符型指针或整数作为参数：
void func(char *);
void func(int);
若调用时候传递一个空指针，则调用void func(int)，这不符合设计人员本意。


32、函数模板
#include<iostream>

template<class T>

void swap(T& a, T& b)
{
    T tmp;
    tmp=a;
    a=b;
    b=tmp;
}

void main()
{
    int a=1,b=2;
    swap(a,b);
    std::cout<<"a="<<a<<", b="<<b<<std::endl;
}





33、类模板
#include<iostream>

template<class T>
class A
{
public:
    A(T value)
    {
        this->value=value;
    }
    T getValue()
    {
        return value;
    }
private:
    T value;

};

void main()
{
    A<int> a(2);

    std::cout<<a.getValue()<<std::endl;
}