C++学习点滴

1.避免使用指针  2.提倡使用库   3.使用类来表示概念。

本文因为随时更新会比较散,定期会整理下.

一些基础知识:

文件结束 EOF=end of file。

标准库的头文件用<>扩起来，非标准库用“”。
C++把负值赋给unsigned完全是合法的，其结果是对该负数对该类型的取值个数求模后的结果。所以如果把-1赋给8位的unsigned char,那么结果是255.
对于无符号整数，摸运算可以转换为多个减运算,对于有符号整数且为负（计算机表示一般为二进制补码）模运算可以转换为+运算。
取模运算时，对于负数应加上被除数的整数倍,使结果大于或等于0后再进行运算。
对于上例,-1+256=255,255%256=255.
附:取模运算与取余运算的区别: 1.c=a/b 2.r=a-c*b
两者区别在第一步:取模运算在取c的值中往0的方向舍入，而求余运算在计算c时则往无穷小的方向舍入。a,b符号一致时,两者结果一致。 具体来             说，求模符号与b一致,求余与a一致（本段内容应属摘抄，当初写在笔记本上没了来源tt）
一般而言，对象就是内存中具有类型的区域。“初始化不是赋值”
构造函数:定义如何进行初始化的成员函数
定义:为变量分配存储空间，定义也是声明。
声明:表明变量的类型和名字。
定义时我们声明了变量的类型和名字，可以用extern关键字声明变量而不是定义他。
在使用extern时要严格对应声明时的格式。
如下:在源文件  char a[6];
在另外一个文件 extern char *a;这是错误的用法,因为extern char *a声明的是一个指针变量而不是一个字符数组.z正确的声明是extern char a[];
通常把一个对象定义在它的使用的地方是个好方法。
const 变量声明后不能改变其值。故一定要初始化。非const变量都默认成extern。
typedef的好处:1.隐藏特定类型的实现 2.简化复杂的类型定义 3. 可以一种类型用于多个目的。
#define的max函数如果嵌套使用的话会变成指数次操作。。。。

C++中引用和指针的区别:

简单的说:指针（定义:*）也有自己的存储空间,只不过是他指象的是一个地址,也就是他的存储空间里放 的是地址.但是引用(定义:&)就是一个变量的别名,给 同一个空间起了来个名字 在给引用赋值时，地址不变，值改变。给指针赋值，地址和值均改

看一段代码:

只有第一个是对的，因为传引用不会产生副本，传入函数内避免复制因为复制开销太大，可以看C++ primer p203.

参数传递总结：
1. 按指调用适用于不被函数更改的小对象
2. 按常量引用调用适用于不被函数更改的大对象
3. 引址调用适用于所有可以被函数更改的对象

通过引用传递数组:数组形参可声明为数组的引用。如果形参是数组的引用，编译器不会将数组形参转化为指针，而是传递数组的引用本身。

条件编译:

在编译预处理的时候对其中伪指令(#开头和特殊符号进行处理)，以下是这些指令的用途:

指令  用途
# 空指令，无任何效果
#include 包含一个源代码文件
#define 定义宏
#undef 取消已定义的宏
#if 如果给定条件为真，则编译下面代码
#ifdef 如果宏已经定义，则编译下面代码
#ifndef 如果宏没有定义，则编译下面代码
#elif 如果前面的#if给定条件不为真，当前条件为真，则编译下面代码，其实就是else if的简写
#endif 结束一个#if……#else条件编译块
#error 停止编译并显示错误信息

C++中const的使用大解:

http://blog.csdn.net/Eric_Jo/article/details/4138548

C++的文件读写:

istream 类型 ， 提供输入操作。

ostream 类型 ， 提供输出操作。

cin: 读入标准 输入的istream对象。

cout: 写到标准输出的ostream对象。

cerr； 输出标准错误的ostream对象。

IO对象不可复制或赋值

流类型是不能作为函数返回值和形参的，必须使用流类型的指针或者引用。

ifstream infile;
infile.open("in");//打开文件名为in的文件
//打开后，通常要检验打开是否成功。
if(!infile) {//读文件不成功；
	cerr<<"error：unable to open input file: "<<infile<<endl;
	return -1;
}
infile.close();//关闭文件

http://blog.csdn.net/shtianhai/article/details/2363841

stringsteam 可以用来做数据转换。详解:

http://blog.csdn.net/cqlf__/article/details/7065138

附2:STL使用总结

向量(vector) <vector>

连续存储的元素<vector>

Vector<int>c;

c.back()    //传回最后一个数据，不检查这个数据是否存在。

c.clear()     //移除容器中所有数据。

c.empty()  // 判断容器是否为空。

c.front()    // 传回地一个数据。

c.pop_back()  // 删除最后一个数据。

c.push_back(elem) // 在尾部加入一个数据。

c[i] 等同于 c.at(i);

列表(list) <list>

由节点组成的双向链表，每个结点包含着一个元素<list>

list<int> list1(1,2,3)

front()  //返回第一个元素的引用  int nRet =list1.front()    // nRet = 1

back() //返回最后一元素的引用  int nRet =list1.back()     // nRet = 3

push_back() //增加一元素到链表尾 list1.push_back(4)       //list1(1,2,3,4)

push_front() //增加一元素到链表头  list1.push_front(4)      //list1(4,1,2,3)

pop_back()  //删除链表尾的一个元素 list1.pop_back()          //list1(1,2)

pop_front() //删除链表头的一元素  list1.pop_front()　         //list1(2,3)

clear() //删除所有元素   list1.clear();   // list1空了,list1.size()=0

sort() //对链表排序，默认升序(可自定义回调函数)

list对象L1(4,3,5,1,4)  L1.sort();

//L1(1,3,4,4,5) L1.sort(greater<int>());

//L1(5,4,4,3,1)

insert()在指定位置插入一个或多个元素

list1.insert(++list1.begin(),9);  // list1(1,9,2,3)

list1.insert(list1.begin(),2,9);  // list1(9,9,1,2,3);

list1.insert(list1.begin(),list2.begin(),--list2.end());//list1(4,5,1,2,3);

swap()交换两个链表(两个重载)

list1.swap(list2);   //list1（4，5，6） list2（1，2，3）

unique()删除相邻重复元素

L1(1,1,4,3,5,1)

L1.unique();// L1(1,4,3,5,1)

merge()合并两个有序链表并使之有序

// 升序list1.merge(list2);          //list1(1,2,3,4,5,6) list2现为空

// 降序L1(3,2,1), L2(6,5,4)L1.merge(L2, greater<int>()); //list1(6,5,4,3,2,1) list2现为空

reverse()反转链表:list1.reverse();     //list1(3,2,1)

remove()删除链表中匹配值的元素(匹配元素全部删除)list对象L1(4,3,5,1,4)L1.remove(4);               //L1(3,5,1);

empty()判断是否链表为空bool bRet =L1.empty(); //若L1为空，bRet = true，否则bRet = false。

rbegin()返回链表最后一元素的后向指针(reverse_iteratoror const)list<int>::reverse_iterator it = list1.rbegin();  //*it = 3

rend()返回链表第一元素的下一位置的后向指针list<int>::reverse_iteratorit = list1.rend(); // *(--riter) = 1

 

集合(set) <set>

由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序 <set>

set<type>: 以less<>为排序法则的set

set<type,op>: 以op为排序法则的set

struct op{

bool operator()(const rec&a,const rec&b){

return a.x<b.x||a.x==b.x&&a.y<b.y;

}

};
1.1 set：：begin

功能：返回第一个元素的定位器（iterator）的地址。

set <char>：：iterator cp;

ctr.insert（’a'）;

ctr.insert（’b'）;

cp=ctr.begin（）; //定位到ctr 的开始位置

1.2 set：：clear

功能：将一个set 容器的全部元素删除。

1.3 set：：count

功能：返回对应某个关键字的元素的个数。好像都是1吧

1.4 set：：empty

功能：测试一个set 容器是否为空。

1.5 set：：end

功能：返回最后一个元素后面的定位器（iterator）的地址。

1.7 set：：erase

功能：将一个或一定范围的元素删除。

1.8 set：：find

功能：求出与给定的关键字相等的元素的定位器。

set <string> ctr;

    ctr.insert(“abc”);

    ctr.insert(“abcd”);

    ctr.insert(“abcf”);

    set <string>::iterator cp;

    cp=ctr.find(“abc”); //查找key=1 的元素

    if(cp!=ctr.end())

        cout<<*cp <<endl;//显示abc

    cp=ctr.find(“adf”); //查找key=2 的元素

    if(cp!=ctr.end())

        cout<<*cp <<endl;//不显示

    cp=ctr.find(“gfv”); //查找key=3 的元素

    if(cp!=ctr.end())

        cout<<*cp <<endl;// 不显示

1.10 set：：insert

功能：将一个元素或者一定数量的元素插入到set 的特定位置中。

1.25 set：：upper_bound

功能：求出指向第一个关键字的值是大于一个给定值的元素的定位器。

cp=ctr.upper_bound（2）;//输出比2大的最小元素

多重集合(multiset)< set>

允许存在两个次序相等的元素的集合 <set>

multiset<type>: 以less<>为排序法则的multiset

multiset<type, op>: 以op为排序法则的multise

struct op{

bool operator()(const rec&a,const rec&b){

return a.x<b.x||a.x==b.x&&a.y<b.y;

}

};
multiset<int>h;

__typeof(h.begin()) c=h.begin();//c指向h序列中第一个元素的地址，第一个元素是最小的元素

printf(“%d “,*c);//将地址c存的数据输出

h.erase(c);//从h序列中将c指向的元素删除

__typeof()是个好东西~

栈(stack)  <stack>

后进先出的值的排列 <stack>

定义一个stack的变量stack<int> s;

入栈，如例：s.push(x);

出栈，如例：s.pop();注意，出栈操作只是删除栈顶元素，并不返回该元素。

访问栈顶，如例：s.top()

判断栈空，如例：s.empty()，当栈空时，返回true。

访问栈中的元素个数，如例：s.size()

队列(queue) <queue>

先进先出的执的排列 <queue>

定义一个queue的变量     queue<Type> M
查看是否为空范例        M.empty()   是的话返回1，不是返回0;
从已有元素后面增加元素M.push()
输出现有元素的个数        M.size()
显示第一个元素              M.front()
显示最后一个元素           M.back()
清除第一个元素              M.pop()

优先队列(priority_queue) <queue>

元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列 <queue>

1、默认从大到小

priority_queue<int> qi;

2、从小到大输出可以传入一个比较函数，使用functional.h函数对象作为比较函数，great<int>(小到大) less<int>(大到小)

priority_queue<int, vector<int>, greater<int> >qi2; 第二个参数为容器类型。第三个参数为比较函数。

3、自定义：

struct cmp  // 最小优先队列

{

bool operator()(const long long i,constlong long j)

{

return i>j;

}

};
priority_queue<int,vector<longlong>,cmp> Q;

 

 

struct node // 最小优先队列

{

int id,len;

bool operator < (const node &b)const// 只能重载小于号

{

return len>b.len;

}

};
priority_queue<node>Q;

 

Q.empty() // 判断队列是否为空返回ture表示空返回false表示空 bool

Q.top() // 返回顶端元素的值元素还在队列里

Q.pop() // 删除顶端元素 void

Q.push(V) // 把long long型的数V加入到队列里它会制动条件V的位置void

Q.size() // 返回队列里元素个数 unsigned int

双端队列(deque) <deque>

连续存储的指向不同元素的指针所组成的数组<deque>

deque<int>c

c.pop_back()      删除最后一个数据。

c.pop_front()      删除头部数据。

c.push_back(elem) 在尾部加入一个数据。

c.push_front(elem) 在头部插入一个数据。

c.clear()          移除容器中所有数据。

c.front()          传回地一个数据。

c.back()          传回最后一个数据，不检查这个数据是否存在。

c.size()           返回容器中实际数据的个数。

c.empty()         判断容器是否为空。

c[i] 等同于 c.at(i);

 

 

映射(map) 由{键，值}对组成的集合 <map>

以某种作用于键对上的谓词排列 <map>

三种插入数据的方法（第一种和第二种是一样的，当map中有这个关键字时，insert操作是插入不了数据的，用数组方式会覆盖以前该关键字对应的值）

1. map<int,string>mapStudent;

   mapStudent.insert(pair<int,string>(1,”student_one”));

mapStudent.insert(pair<int,string>(2,”student_two”));

2. map<int,string>mapStudent;

   mapStudent.insert(map<int,string>::value_type(1,”student_one”));

   mapStudent.insert(map<int,string>::value_type(2,”student_two”));

3. map<int,string>mapStudent;

mapStudent[1]=”student_one”;

mapStudent[2]=”student_two”;

可以用pair来获得是否插入成功

map<int,string>mapStudent;

pair<map<int,string>::iterator,bool> insert_pair;

insert_pair=mapStudent.insert(pair<int,string>(1,”student_one”));

if(insert_pair.second==true)

     cout<<”insert Successfully”<<endl;

怎么知道当前已经插入了多少数据呢，可以用size函数，用法如下：int nSize=mapStudent.size();

清空map中的数据可以用clear()函数，判定map中是否有数据可以用empty()函数

要判定一个数据（关键字）是否在map中出现的方法比较多，这里给出三种数据查找方法

第一种：用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置,由于map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的情况，返回1

         map<int,string> mapStudent;

     mapStudent.insert(pair<int,string>(1,”student_one”));

     mapStudent.insert(pair<int,string>(2,”student_two”));

     mapStudent.insert(pair<int,string>(3,”student_three”));

     int t1,t2;

     t1=mapStudent.count(4);

     t2=mapStudent.count(1);

第二种：用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器

         map<string,int>mapStudent;

         mapStudent.insert(pair<string,int>(“student_one”,1));

         mapStudent.insert(pair<string,int>(“student_two”,2));

         mapStudent.insert(pair<string,int>(“student_three”,3));

         map<string,int>::iteratoriter;

         charch[]=”student_three”;

         iter=mapStudent.find(ch);

         if(iter!=mapStudent.end())

                   cout<<”Find,the value is: “<<iter->second<<endl;

         else

                   cout<<”Donot Find”<<endl;

清空map中的数据可以用clear()函数，判定map中是否有数据可以用empty()函数，它返回true则说明是空

//如果要删除,用迭代器删除

map<int,string>::iterator iter;

iter=mapStudent.find(1);

mapStudent.erase(iter);

//如果要删除，用关键字删除

intn=mapStudent.erase(1);//如果删除了n会返回，否则返回

//用迭代器，成片的删除

mapStudent.erase(mapStudent.begin(),mapStudent.end());

//一下代码把整个map清空

mapStudent.erase(mapStudent.begin(),mapStudent.end());

排序

一、

#include <map>

#include <string>

using namespace std;

typedef struct tagStudentInfo

{

int      nID;

string   strName;

booloperator < (tagStudentInfo const& _A) const

{

//这个函数指定排序策略，按nID排序，如果nID相等的话，按strName排序

if(nID< _A.nID)

return true;

if(nID== _A.nID)

return strName.compare(_A.strName) < 0;

returnfalse;

}

}StudentInfo, *PStudentInfo;  //学生信息

int main()

{

//用学生信息映射分数

map<StudentInfo, int>mapStudent;

StudentInfo studentInfo;

studentInfo.nID = 1;

studentInfo.strName ="student_one";

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));

studentInfo.nID = 2;

studentInfo.strName ="student_two";

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));

}
二、

#include <map>

#include <string>

#include <iostream>

using namespace std;

typedef struct tagStudentInfo

{

int      nID;

string   strName;

} StudentInfo, *PStudentInfo; //学生信息

struct sort

{

bool operator() (StudentInfo const &_A, StudentInfo const &_B)const

{

if(_A.nID < _B.nID)

return true;

if(_A.nID == _B.nID)

return _A.strName.compare(_B.strName) < 0;

return false;

}

};

int main()

{

//用学生信息映射分数

map<StudentInfo, int, sort>mapStudent;

StudentInfo studentInfo;

studentInfo.nID = 1;

studentInfo.strName = "student_one";

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 90));

studentInfo.nID = 2;

studentInfo.strName = "student_two";

mapStudent.insert(pair<StudentInfo, int>(studentInfo, 80));

map<StudentInfo, int>::reverse_iterator iter;

for(iter=mapStudent.rbegin();iter!= mapStudent.rend();iter++)

cout<<iter->second<<endl;

}

 

多重映射(multimap)  <map>

允许键对有相等的次序的映射 <map>

比如在电话簿中相同的人可以有两个以上电话号码，文件系统中可以将多个符号链接映射到相同的物理文件，或DNS服务器可以将几个URLs映射到相同的IP地址。

查找

1. 直接找到每种键值的所有元素的第一个元素的游标。

通过函数：lower_bound( const keytype& x ), upper_bound( const keytype&x ) 可以找到比指定键值x的小的键值的第一个元素和比指定键值x大的键值的第一个元素。返回值为该元素的游标。

细节：当到达键值x已经是最大时，upper_bound返回的是这个multimap的end游标。同理，当键值x已经是最小了，lower_bound返回的是这个multimap的begin游标。

2. 指定某个键值，进行遍历

可以使用上面的lower_bound和upper_bound函数进行游历，也可以使用函数equal_range。其返回的是一个游标对。游标对pair::first是由函数lower_bound得到的x的前一个值，游标对pair::second的值是由函数upper_bound得到的x的后一个值。

multimap<int,int>a;

a.insert(pair<int,int>(1,11));

a.insert(pair<int,int>(1,12));

a.insert(pair<int,int>(1,13));

a.insert(pair<int,int>(2,21));

a.insert(pair<int,int>(2,22));

a.insert(pair<int,int>(3,31));

a.insert(pair<int,int>(3,32));

multimap<int,int>::iterator p_map;

pair<multimap<int,int>::iterator,multimap<int,int>::iterator> ret;

for(p_map = a.begin() ; p_map != a.end();)

{

cout<<p_map->first<<" =>";

ret = a.equal_range(p_map->first);

for(p_map= ret.first; p_map != ret.second; ++p_map)

cout<<" "<< (*p_map).second;

cout<<endl;

}