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>
classTest
{
private:
inta;
intb;
public:
Test():
a(1),b(2)
{

}
Test(inta,intb)
{
this->a=a;
this->b=b;
}
intgetA()
{
returnthis->a;
}
intgetB()
{
returnthis->b;
}
};

​

14、拷贝构造函数

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

​

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

​

16、如果未提供自己的拷贝构造函数，则C++提供一个默认拷贝构造函数，就像没有提供构造函数时，提供默认构造函数一样。

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

出现指针成员变量的类中一定要自己写拷贝构造函数

​

17、成员方法加const表示该方法不会修改类成员。以下会报错：

voidalterB()const
{
this->b=this->b+1;
}

​

18、运算符重载的格式如下

returnTypeoperatorsymbol(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指针

Countoperator=(constCount&t)
{
if(this==t)
returnthis;
deletethis->value;
value=newint;
*value=t.getValue();
return*this;
}

​

20、转换运算符

（1）内置类型变量赋值给一个用户定义类型对象

inti=0;
Count t=i;

只需要在Count类中提供一个带int 参数的构造方法即可

（2）用户定义类型对象赋值给内置类变量

Count t (2) ;
inti=t;

需要在Count类中指定转换运算符，如下(下划线部分)：

classCount
{
public:
Count(intvalue){this->value=value;}
operatorunsignedint(){returnvalue;}
private:
intvalue;
}

​

21、继承

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

​

22、隐藏

在c++中，如果子类隐藏了父类的函数，则父类中的所有同名函数都会被隐藏！！！

#include<iostream>
classParent
{
public:
Parent(){}
Parent(intvalue){this->value=value;}
~Parent(){}
Parent(Parent&){}
voidmove(){std::cout<<"Parent moves "<<value<<" step!"<<std::endl;}
voidmove(intn){std::cout<<"Parent moves "<<n<<" step!"<<std::endl;}

protected:
intvalue;
};
classChild:publicParent
{
public:
Child(){}
Child(intvalue,intspecial):
Parent(value),
special(special)
{

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

Parent *p;

p->move(3);//right！！！

}

在java中，如果子类隐藏了父类的函数，则父类中的其他同名函数不会被隐藏！！！下面是java代码

publicclassParent{
protectedintvalue;
publicParent(){
}
Parent(intvalue){
this.value=value;
}
publicvoidmove(){
System.out.println("parentmoves"+value+"steps!");
}
publicvoidmove(intn){
System.out.println("parentmoves"+n+"steps!");
}
}
publicclassChildextendsParent{
Child(){
super();
}
Child(intvalue){
super(value);
}
publicvoidmove(){
System.out.println("childmoves"+value+"steps!");
}
publicstaticvoidmain(String[]args){
Childchild=newChild(1);
child.move(2);//right！！！
}
}

​

23、多态

要实现多态，就要声明为虚函数virtual，这与java是有区别的（java不需要声明virtual）。

classParent
{
public:
Parent(intvalue){this->value=value;}
virtualvoidfunction(){}
private:
intvalue;
};
classChild:publicParent
{
public:
Child(intvalue):
Parent(value),
c('0')//不能将父类parent的value属性这样初始化。value只能如上句，或者在下面的函数体内初始化
{}
voidfunction(){std::cout<<"test"<<std::endl;}
private:
charc;
};

​

24、在多态的使用中，只有通过指针和引用进行调用时，才能发挥虚函数的魔力；按值传递对象时不能发挥虚函数魔力。按值传递只能够保留父类的方法，切除子类特有方法。

#include<iostream>
classParent
{
public:
Parent(){}
Parent(intvalue){this->value=value;}
~Parent(){}
Parent(Parent&){}
virtualvoidmove(intn){std::cout<<"Parent moves "<<n<<" step!"<<std::endl;}
protected:
intvalue;
};
classChild:publicParent
{
public:
Child(){}
Child(intvalue,intspecial):
Parent(value),
special(special)
{

}
voidmove(intn){std::cout<<"Child moves "<<n<<" step!"<<std::endl;}
private:
intspecial;
};
voidmain()
{
Parent*p=newChild(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！，即子类的方法被切除，调用父类方法
deletep;
}

​

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

​

26、C++中用纯虚函数来支持抽象数据类型ADT，抽象类和函数。java中用abstract关键字。

任何包含一个或多个纯虚函数的类都是ADT，不能对其实例化，试图这样做将导致编译错误。

a、不能创建这个类的对象，只能从其派生

b、务必重写从这个类继承的纯虚函数

#include<iostream>
classParent
{
public:
Parent(){}
Parent(intvalue){this->value=value;}
~Parent(){std::cout<<"destructor"<<std::endl;}
Parent(Parent&){}
virtualvoidmove()=0;
protected:
intvalue;
};
classChild:publicParent
{
public:
Child(){}
Child(intvalue,intspecial):
Parent(value),
special(special)
{

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

​

27、不要忘记给静态成员变量赋初值。不像java，变量可以直接在类中声明处赋值，c++中的变量赋值不能在类中声明处赋初值

#include<iostream>
classParent
{
public:
Parent(){}
Parent(intvalue){this->value=value;}
~Parent(){}
Parent(Parent&){}
intvalue;
staticintnum;
};
int Parent::num=0;

​

28、要将私有成员或函数暴露给另一个类，必须将其声明为友元类，友元关系不能传递，不能继承，也不可交换，将Class1声明为Class2的友元并不能让Class2成为Class1的友元。有时候不想将友元访问权限赋予整个类，为此，可以将成员函数而不是整个类声明为友元。

友元函数：友元函数的声明可以放在类的私有部分，也可以放在公有部分，它们是没有区别的，都说明是该类的一个友元函数

#include<iostream>
classParent
{
public:
Parent(){}
Parent(intvalue){this->value=value;}
~Parent(){}
Parent(Parent&){}
friendvoidgetValue(Parent& p);
private:
intvalue;
};
voidgetValue(Parent&p)//不需要加Parent::,因为友元函数不属于该类
{
std::cout<<p.value<<std::endl;
}
voidmain()
{
Parent p(2);
getValue(p);//友元函数不属于类，直接调用，无需对象表示
}

友元类：一个类能够作另一个类的友元。当一个类作为另一个类的友元时，这就意味着这个类的任何成员函数都是另一个类的友元函数。

以下语句说明类B是类A的友元类：

#include<iostream>
classA
{
public:
A(){}
A(intvalue){this->value=value;}
~A(){}
A(A&){}
friendclassB;
private:
intvalue;
};
classB
{
public:
B(){}
~B(){}
B(B&){}
voidgetValue(A&a)
{
std::cout<<a.value<<std::endl;
}
};
voidmain()
{
A a(2);
B b;
b.getValue(a);
}

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

29、函数指针

可以声明指向函数的指针，其实函数名就是指向函数的常量指针，就像数组名是指向数组第一个元素的常量指针一样。

#include<iostream>

voidadd(inta,intb)
{
std::cout<<a+b<<std::endl;
}
voidsubtract(inta,intb)
{
std::cout<<a-b<<std::endl;
}

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

30、将函数指针作为参数传递

#include<iostream>

voidadd(inta,intb)
{
std::cout<<a+b<<std::endl;
}
voidsubtract(inta,intb)
{
std::cout<<a-b<<std::endl;
}
voidprintValue(void (*func)(int, int),inta,intb)//函数指针作为参数
{
func(a,b);
}
voidmain()
{
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<classT>

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

voidmain()
{
inta=1,b=2;
swap(a,b);
std::cout<<"a="<<a<<", b="<<b<<std::endl;
}

33、类模板

#include<iostream>

template<classT>
classA
{
public:
A(T value)
{
this->value=value;
}
T getValue()
{
returnvalue;
}
private:
T value;

};

voidmain()
{
A<int>a(2);

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