C++基础与核心及STL相关

1.类和对象

1.1类的相关实现

第一种方法是将类的成员函数定义在类体内，这里不再介绍
第二种方法是将类体内的成员函数的实现放在类体外，此时需要域运算符“：：”，和第一种效果一样。

class apple{    public://数据成员    int index;//成员函数    int getindex();};//类成员函数实现部分int apple::getindex(){    return index;}

C++语言一般在头文件放入函数的声明，在cpp文件里面放入函数的实现，同样可以在头文件里面放入类的定义，将类的成员函数实现在实现文件内，存放类的头文件和实现文件最好和类的名称相同。例如：

//apple.h文件#include<stdio.h>#include....class apple{    public:    int index;    int getindex();}...

//apple.cpp文件#include<apple.h>...int apple::getindex(){    return index;}...

1.2构造函数

#include<iostream>class apple{    public:        apple();        apple(int iindex,short isize);        int index;        short size;    ...}//默认构造函数初始化apple::apple(){    index=1;    size=2;}//在带参数的构造函数中初始化apple::apple(int iindex,short isize){    index=iindex;    size=iisize;}int apple::getindex(){    return index;}...void main(){    apple a1;    cout<<a1.getindex()<<endl;      //输出1    apple a2(10,20);    cout<<a1.getindex()<<endl;      //输出10}

1.3类成员

如果在类定义的时候没有加任何关键字，默认状态成员都在private区域。

1.3.1静态类成员

若将类成员定义为静态类成员，则允许使用类名直接访问，大概是因为叫这个名字的只有一个大家的值都一样吧，用类直接访问不用担心混淆，静态类成员是在类成员定义前使用static关键字标识。在定义静态数据成员时，通常需要在类体外对静态数据成员初始化。例如：

class apple{    public:    static unsigned int price;  //定义一个静态数据成员}unsigned int apple::price=10;   //初始化静态数据成员...int main(...){    apple a1;    cout<<apple::price<<endl;       //通过类名访问静态成员    cout<<a1.price<<endl;           //通过对象访问静态成员}

在定义类的数据成员时，可以为成员函数指定默认参数，其参数默认值可以是类的静态数据成员，但是普通数据成员则不能作为函数默认参数。
另外静态成员函数只能访问静态数据成员
在定义静态数据成员函数时，如果函数的实现代码处于类体之外，则在函数的实现部分不能在标static关键字。

class apple{    public:    static unsigned int price;    int abc;    void output(int data =price)    //以静态数据作为默认参数    {    cout<<data<<endl;    }    void out(int data=abc)          //错误，普通成员不能作为默认参数    {        ...    }    static void outt()    {    cout<<price<<endl;              //正确的访问    cout<<abc<<endl;                //错误的访问，不能访问非静态    }    ...} ；    static void apple::outt();      //错误的定义

关于嵌套类和友元相关需要的时候再补充。

2.继承与派生

2.1类的继承

继承有3种派生方式，public,protected,private,”:”表示基类和派生类之间的继承关系，例如:

class phone{    public:    int size;    char name[10];};class iphone:public phone{    public :    char version[10];    int  sizes;}

注意：私有成员不能被继承，在派生时若子类中定义了一个与父类同名的成员函数，此时子类会隐藏父类的成员函数

2.2继承后的可访问性

公有型派生后基类该什么型还什么样，privated的还是不能访问
保护型派生后原来的public和protected成员在派生类中均为protected,只是在派生类定义的时候可以访问，用派生类定义的对象不能访问，在类体外也不能访问，也就是说，protected成员可以被基类所有派生类使用，就是不能更改。
私有型派生基类中的private还是不能访问。

2.3构造函数访问顺序

从父类派生一个子类并声明一个子类对象时，它将先调用父类的构造函数，然后调用当前类的构造函数来创建对象，在释放对象的时候，先调用的是当前类的析构函数，最后是父类的析构函数。
无论调用的是那种子类的构造函数，都会先调用父类默认的构造函数，若想用父类带参数的构造函数则需要显示调用。例如:

#include.......class father{    public:    int ID;    char name [10];    father(char name[10])    {    strcpy(char name[]);    }    father()    {    strcpy(name,"HH");    }    ...};class son:public father{    public:    char smallname[10];    son(char name[]):father(name)    {    cout<<.....<<endl;    }};int main(...){    son jack("jack");}

3.STL标准库模板

标准模板库，即STL，是根据本地C++标准规范定义的一套强大的函数模板类模块库。它主要包含容易，算法，函数对象。

3.1结合容器

结合容器主要通过关键码提高查询和操作的效率。一般包括set,multiset,map…
以下几个例子

3.1.1multiset类模板

multiset是程序能顺序存储一类数据，与集合类相似，多重集合的元素既可以作为存储的数据，又可以作为数据的关键字，于集合类不同的是可以包含重复的数据。

multiset<int> imul;imul.insert(1);imul.insert(2);...multiset<int>::iterator it;         //定义相关迭代器for(it=imul.begin();it!=imul.end();it++)    cout<<*it<<endl;    int target=1;it=imul.find(target);if(it==imul.end())    cout<<"not found"<<endl;    else    cout<<"founded"<<endl;

其他容器类似，不再赘述，后面主要介绍算法。

3.2算法

算法是STL中枢，STL提供了算法库，算法库中都是模板函数，迭代器主要负责从容器中获取一个对象，算法与具体对象在容器的什么位置等细节无关。
标准算法分四个类别：非修正序列算法，修正序列算法，排序算法，数值算法。

3.2.1非修正序列算法

非修正序列算法不修改他们所作用的容器，例如计算个数或者查找元素的函数，STL提供的主要非修正序列算法（常用）如下：

count(first,last,val)           //计数equal(first,last,first2)        //判断相等find(first,last,val)            //搜索for_each(first,last,func)       //对范围内的元素进行func操作

下面举个简单的例子:

#include <iostream>#include <vector>#include <algorithm>using namespace std;void Output(int val){    cout << val << ' ';}void  main(){    vector<char> charVect;    charVect.push_back('M');    charVect.push_back('L');    charVect.push_back('A');    charVect.push_back('G');    charVect.push_back('v');    charVect.push_back('U');    for_each(charVect.begin(), charVect.end(), Output);    cout << endl;    sort(charVect.begin(), charVect.end());    for_each(charVect.begin(), charVect.end(), Output);    int cnt=count(charVect.begin(),charVect.end(),5);    cout<<cnt<<endl;    system("pause");}

3.2.2修正序列算法

修正序列算法有些操作会改变容器的内容，例如复制或者指定填充，只列出主要的算法，不再举例。

copy(first,last,first2);                //复制copy_backward(first,last,first2);       //逆向复制random_shuffle(first,last);             //随机重排swap(it1,it2);                          //置换replace(first,last,val1,val2);          //取代某种元素fill（first,last,val);                   //改填元素值

3.2.3排序算法

排序算法的特点是对容器的内容进行不同方式的排序，常用算法如下：。

max(val1,val2);                 //最大值min_elemnent(first,last);       //最小值所在位置sort(first,last);               //升序排序partial_sort(first,middle,last);//局部排序

下面举个简单的例子:

#include <iostream>#include <vector>#include <algorithm>using namespace std;void Output(int val){    cout << val << ' ';}void  main(){    vector<char> charVect;    charVect.push_back('M');    charVect.push_back('L');    charVect.push_back('A');    charVect.push_back('G');    charVect.push_back('v');    charVect.push_back('U');    for_each(charVect.begin(), charVect.end(), Output);    cout << endl;    part_sort(charVect.begin(), charVect.begin()+3,charVect.end());    for_each(charVect.begin(), charVect.end(), Output);  //对迭代器first到last范围内元素进行排序，把排序后的前一部分元素放到序列前一部分first-mid，其余部分放在后一部分mid-last。    system("pause");}

3.3迭代器

迭代器相当于指向容器的元素的指针，他在容器内可以各种移动，有输入，输出，和随机操作的迭代器，下面细说。

3.3.1输出迭代器

输出迭代器只用于写一个序列，它可以进行递增和提取操作

#include<iostream>#include<vector>using namespace std;void main(){    vector<int> intVect;    for(int i=0;i<10;i+=2)        intVect.push_back(i);    cout<<endl;    vector<int>::iterator it=intVect.begin();    while(it!=intVect.end())        cout<<*it++<<endl;}

3.3.2输入迭代器

输入迭代器只用于读一个序列，它可以进行递增，提取，比较操作

#include<iostream>#include<vector>using namespace std;void main(){    vector<int> intVect（5）;    vector<int>::iterator out=intVect.begin();    *out++=1;    *out++=3;    *out++=5;    *out++=7;    *out=9;    cout<<endl;    vector<int>::iterator it=intVect.begin();    while(it!=intVect.end())        cout<<*it++<<endl;}

3.3.3随机访问迭代器

随机访问迭代器最强大，不仅具有双向迭代器的所有功能，还能使用指针的算术运算和比较运算。

#include<iostream>#include<vector>using namespace std;void main(){    vector<int> intVect（5）;    vector<int>::iterator it=intVect.begin();    *it++=1;    *it++=3;    *it++=5;    *it++=7;    *it=9;    cout<<endl;   for(it=intVect.begin();it!=intVect.end();it++)        vout<<*it<<endl;    it=intVect.begin();    *(it+2)=100;        //此时输出第三个元素已经变为100；    while(it!=intVect.end())        cout<<*it++<<endl;}

到此重新温习了一遍C++里面从基础的类到继承派生再到最后学习了强大的STL库，还有一些文件流和网络通信等方面各种语言都大同小异，另外C++11的新特性如lambda表达式等用到的时候再补充吧，希望自己保持良好的习惯，以后在项目中关于C++的心得经验再在这里继续记录。