C++被忽视语言点总结

1、#define PI 3.1415926

缺点：define宏定义只在预编译的时候进行字符置换，预编译之后，程序中不再有PI这个标识符，PI不是变量，没有类型，不占用内存单元，也就意味着不能用指针。

替代方法：const float PI 3.1415926

利用const就可以声明一个常量。

2、C++之所以要加入引用主要是利用它作为函数参数，以扩充函数传递数据的能力。

3、可用常量或表达式对引用进行初始化，但此时必须用const声明。

如：  int i=5;

       const int &a=i+5;

因为编译系统会生成一个临时变量，用来存放i+5的值，引用的是该临时变量的值。即  temp=i+5;   int &a=temp;

若不加上const则当a改变的时候，只能改变temp的值，不会影响到i，所以为了避免用户犯错误（经常会认为引用会改变原值），所以就干脆声明为const，从而避免的这种错误。

4、内置函数inline:可以提高运行效率，因为调用一个函数的时间远远大于小规模函数体中全部语句的执行时间。

用内置函数可以达到用#define定义带参宏的目的。如：

关键是内置函数不会是简单的代码替换，他会自己加上括号；但define就不能

# define sum(x,y) x+yinline sum(int x,int y)
{
return x+y;
}

5、在类内部定义的函数默认为inline（内置函数），也可以省略不写；但在类的外部定义的函数就不是内置函数，除非你显示的声明。另外如果你在类外定义了内置函数，则必须将类定义和成员函数的定义放在同一个文件中。因为编译器是按照一个文件一个文件编译的，内置函数在另一个文件会导致编译错误。但这样就不利于信息隐蔽。

另外，在类中不论是否用inline声明，都不会占用对象的存储空间。inline的作用是在调用该函数时，将函数代码复制插入到函数调用点；如不用inline则流程会转去函数的代码段的入口地址，执行完以后再返回程序，类似于中断一样。

 

6、应该注意区分什么时候用作用域运算符“::”,什么时候用成员运算符“.”。

在定义类成员函数的时候、在使用某个数据成员需要进行限定的时候用"::”。如： int compare::max(){….}     或cout<<compare::x

在使用一个对象的成员时用“.”。如stud1.getdata()

7、类的构造函数是不能被用户显式调用的。另外，一个类只能有一个默认构造函数。

如  

class Box{
   public:
      Box();
      Box(int w=13,int h=12);
………
}

8、析构函数的作用并不是删除对象，而是在撤销对象占用的内存之前完成一些清理工作，是这部分程序内存可用系统使用。

9、对于同一类存储类别的对象而言，遵守“先构造后析构”的原则；如

同一类存储
stud stud1;
stud stud2;
不同类存储
------------------------------
stud stud1;
complex com1;

但由于作用域和存储类别的不同，不同类的对象析构函数调用的顺序是不确定的。不要想当然的认为。

10、指向类成员函数的指针与普通函数指针的定义区别

普通函数指针类成员函数fun()//已定义的一个函数
void (*p)();
p=fun;Time//是一个类
void (Time:: *p)();
p=&Time::gettime;//没有()只有函数名

11、const声明总结

const int b=5; //定义一个常量

const Time t1(12,35,34);//定义一个常对象

int gettime() const;//定义一个常成员函数

const int *p=&a;//指向常量的指针

Time * const p=&t1;//指向对象的常指针

关键是看清楚const关键字举例什么较近。

12、非静态成员函数有this指针，但是静态成员函数没有this指针。静态成员函数主要用来访问静态成员。

13、函数模板和类模板

函数模板类模板template <typename T>
T max(T a,T b)
{
………
}

使用
max（15,16）;template <class T>
class compare{
public:
      compare(T a,T b)
      {……}
     T max(){return a>b?a:b}
       ………
}

类外声明成员函数
template <class T>
T compare <T>::compare(){….}

使用
compare <int> max(6,8);

14、对象数组的初始化

student stud[3]={

         student(1001,18,34);

         student(1002,18,34);

        student(1003,18,34);

}

15、c++提供虚基类方法，使得在继承共同的基类的时候只保留一份相同的数据成员。

class A
{…};
class B:virtual A
{…};
class C:virtual A
{…};
class D:public B,public C
{
   D(…):A(…),B(…),C(…){} //基类也要写上
…};

1、应该把所有基类的直接基类都用virtual来声明；
2、c++编译系统只执行最后的派生类对虚基类的构造函数的调用，这就保证不会对基类进行多次初始化

16、静态多态性是通过函数重载来实现的；动态多态性是通过虚函数来实现的。

要明白虚函数的作用过成：先在基类中定义一个虚函数，然后定义其他派生类；当类定义完了以后，定义一个指向基类的指针，通过该指针的不同指向来调用不同派生类的函数。

17、++重载  类的成员函数

前置++后置++Time Time::operator ++ ()
{
if(++sec>=60)
{sec-=60;++minute;}
return *this;
}Time Time::operator ++ (int)
{  Time temp(*this);    //对象复制
if(sec++>=60)
{sec-=60;++minute;}
return temp;
}18、>>/<<重载  类的友元函数friend ostream& operator <<(oatream &,complex&);   //声明
……
ostream &operator <<(ostream &output,complex &c)
{output<<c.x<<”+"<<c.y<<endl;
return output;}

 

19、几个类中常见函数

1、默认构造函数   complex()

2、用于初始化的构造函数 complex(int a,int b)

3、复制构造函数 complex(complax &c)

4、转换构造函数 complex (double r){real=r;img=0;}

5、类型转换函数 operator double(){return real;}