我们来看一个简单的指向引用的指针的例子。

#include
using namespace std;
int main(){
int x=10;
int y=20;
int &rtx=x;
//不要写成了int& *ptrx=&rtx;
//因为rtx的本质是一个int
int *ptrx=&rtx;
*ptrx=15;
ptrx=&y;
rtx=y;
cin.get();

}

依次单步执行：（注意rtx值的变化和ptrx的变化） 初始化引用rtx之后,rtx指向了x,其地址和&x一致。 执行int *ptrx=&rtx;之后，初始化了ptrx,也是指向x; *ptrx=15;这一句执行后的结果 可以看到，改变的依旧是其值，其指向依旧没有改变，同时x的值也会随之改变。 执行ptrx=&y之后 可以看到ptrx的指向改变了，这是肯定的，但是rtx的指向并没有改变。 执行 rtx=y之后，是否指向会改变呢？答案是肯定的，不会！ 改变的依旧是rtx所指向的值！这就是指向引用的指针。  

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

可以创建任何类型的引用，包括指针类型。 看一个简单的指针的引用的例子。例如：  

#include
using namespace std;
int main(){
int x=10;
int y=20;
int z=30;
int* ptx=&x;
int* ptz=&z;
//指针的引用,声明从右往左看，rtp与&结合，
//剩余的符号和左边结合
//引用一旦创建，不能改变其指向，只能改变其值
int* &rtp=ptx;
cout<<”&x=”<<&x<<endl;
cout<<”&ptx=”<<&ptx<<” “<<”&rtp=”<<rtp<<endl;
cout<<”ptx=”<<ptx<<” “<<”rtp=”<<rtp<<endl;
cout<<”*ptx=”<<*ptx<<” “<<”*rtp=”<<*rtp<<endl<<endl;
ptx=&y;
//ptx的值改变了，rtp的值也相对改变了
//但其指向不变
cout<<”&y=”<<&y<<endl;
cout<<”&ptx=”<<ptx<<” “<<”&rtp=”<<rtp<<endl;
cout<<”ptx=”<<ptx<<” “<<”rtp=”<<rtp<<endl;
cout<<”*ptx=”<<*ptx<<” “<<”*rtp=”<<*rtp<<endl<<endl;
rtp=ptz;
//rtp的值改变了，ptx的值也相对改变了
//但rtp指向不变
cout<<”&ptz=”<<&ptz<<endl;
cout<<”&ptx=”<<ptx<<” “<<”&rtp=”<<rtp<<endl;
cout<<”ptx=”<<ptx<<” “<<”rtp=”<<rtp<<endl;
cout<<”*ptx=”<<*ptx<<” “<<”*rtp=”<<*rtp<<endl<<endl;

}

输出结果： 这样看不明显，我们来简化一下例子，并通过调试来查看其变量地址以及值。  

#include
using namespace std;
int main(){
int x=10;
int y=20;
int z=30;
int* ptx=&x;
int* ptz=&z;
//指针的引用,声明从右往左看，rtp与&结合，
//剩余的符号和左边结合
//引用一旦创建，不能改变其指向，只能改变其值
int* &rtp=ptx;
ptx=&y;
//ptx的值改变了，rtp的值也相对改变了
//但其指向不变
rtp=ptz;
//rtp的值改变了，ptx的值也相对改变了
//但rtp指向不变

}

单步运行截图：（看ptx和rtp的值） 可以看到，rtp一直指向0x22fed8,而这个地址，正是&ptx的地址，从这里可以看出，引用一旦创建其指向不可改变，能改变的只是其值（ptx的值）！ 这就是指针的引用，指向引用的指针请看下一篇博文！

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

首先来看看百度百科对”谓词函数”的定义说明:

1定义编辑

一个判断式，一个返回bool值的函数或者仿函数。几元就是函数有几个参数，至于定义和使用，函数定义和一般的函数定义一样，仿函数就是写个类，然后重载operator()。使用就是在那些以这种需要返回bool值的函数作参数的函数里用了。

一元谓词函数举例如下

1，判断给出的string对象的长度是否小于6

bool GT6(const string &s)

{

return s.size() >= 6;

}

2,判断给出的int是否在3到8之间

bool Compare( int i ) { return ( i >= 3 && i <= 8 ); }

二元谓词举例如下

1，比较两个string对象，返回一个bool值，指出第一个string是否比第二个短

bool isShorter(const string &s1, const string &s2)

{

return s1.size() < s2.size();

}

谓词函数主要用于STL算法.例如下面的一个例子

#include
#include
#include
using namespace std;
bool isZero(int num){
return num==0;
}
int main(){
vector v1={10,11,12,13};
vector v2({7,8,9,15,0});
auto b1=find_if(v1.begin(),v1.end(),isZero);
if(b1!=v1.end()){
cout<<”v1存在元素0!”<<endl;
}else{
cout<<”v1不存在元素0!”<<endl;
}
auto b2=find_if(v2.begin(),v2.end(),isZero);
if(b2!=v1.end()){
cout<<”v2存在元素0!”<<endl;
}else{
cout<<”v2不存在元素0!”<<endl;
}

}

find_if()接受一个谓词函数回调作为参数. find_if()算法对范围内每个元素调用谓词,直到这个谓词返回true; 如果返回true,find_if()返回引用这个元素的迭代器.否则返回超尾迭代器.  

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

有时候我们想将一个类类型转换为另一个类类型,同时,这两个类并不存在继承关系,这时候我们就需要一种叫做转换运算符的运算符. 一个简单的例子.要将类A转换为int类型 #include #include using namespace std; class A{ private: int n; string str; public: A(int m,string s):n(m),str(s){ } }; int main(){ A a(10,”hello”); int m=a; cout<<”m=”<<m<<endl; //string s=a; //cout<<”s=”<<s<<endl; } 编译结果 可能你想将其强制转换.例如 int m=(int)a; 结果还是不行,因为编译器依然不知道应该怎么转换. 这时候,就需要转换运算符了. 这个转换运算符的类型如下: operator int ()const{ return n; } 函数名为operator int ,这个函数是没有返回类型的,因为返回类型是通过运算符的名称确定的:int 同时应声明为const,因为不会修改被调用的对象. 整个程序如下: #include #include using namespace std; class A{ private: int n; string str; public: A(int m,string s):n(m),str(s){ } operator int ()const{ return n; } operator string()const{ return str; } }; int main(){ A a(10,”hello”); int m=a; cout<<”m=”<<m<<endl; string s=a; cout<<”s=”<<s<<endl; } 运行结果: 类类型转换为基本类型是这样,同样,转换为其他类类型也是同样的道理. #include #include using namespace std; class A{ private: int n; string str; public: A(int m,string s):n(m),str(s){ } A(string s){ str=s+” is called!”; } operator int ()const{ return n; } operator string()const{ return str; } void show()const{ cout<<”str=”<<str<<endl; } }; class B{ private: string s; public: B(string str):s(str){ } operator A()const{ return s; } }; int main(){ B b(“this is b “); A a=b; a.show(); } 结果: 这样,我们就可以对不是同一条继承链上的类进行转换了!

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

模版在C++中具有非常重要的地位，STL就是大量运用模版写出来的。 模版的优点我就不一一列举了。这里我只说一下模版的原理。 当编译器遇到模版方法定义的时候，编译器进行语法检查，但是并不会编译模版。编译器无法编译模版定义，因为编译器不知道要使用的类型是什么，编译器不知道x和y的类型的情况下无法为x=y这样的语句生成代码。 当编译器遇到一个实例化的模版的时候，例如vector vi（这里我只是拿vector举例，实际上基本类型的vector代码好像会自动存在编译器中）,编译器会将模版类定义中的每一个T替换为int,从而生成vector的int版本。当模版遇到这个模版的另一个实例的时候，例如vector,就会生成相应的string版本代码。 1.选择性实例化。 编译器只会为那些实际为某个类型调用的类方法生成代码。  

#include
using namespace std;
template
class test{
private:
T data;
public:
test(T d):data(d){
}
void show()const{
cout<<”this data is “<<data<<endl;
}

};
int main()
{
test ti(15);
ti.show();
test ts(“string”);
ts.show();

}

例如上面的例子编译器只会生成test的int以及string版本，其他的如double,char等版本则不会生成。 —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

C++允许模版化类中的单个方法，这些方法可以在一个类模版中，也可以在一个非模版化的类中。 在编写一个模版化的类方法时，实际上是为不同类型编写不同版本的方法，在类模版中，方法模版对赋值运算符和复制构造函数非常有用。 要注意的是，不能用方法模版编写虚方法和析构函数。 1.一个普通类中的方法模版例子：  

#include
using namespace std;
class man{
private:
string name;
public:
man(const string &m):name(m){
}
template
void show(T t){
cout<<”This is “<<t<<” vesion:”<<name<<endl;
}

};
int main()
{
man m(“guang”);
m.show(100);
m.show(“string”);
m.show(0.999);
}

运行结果： 2.一个模版类中的方法模版例子 其实两者的差别并不大。  

#include
#include
using namespace std;
template
class man{
private:
string name;
T data;
public:
man(const string &m,T d):name(m),data(d){
}
template
void show(TT t){
cout<<”This is “<<t<<” vesion:”<<endl;
cout<<”name=”<<name<<” ,data=”<<data<<endl;
}

};
int main()
{
man m(“guang”,10);
m.show(100);
m.show(“string”);
m.show(0.999);

cout<<endl<<endl;
man ms(“jing”,”love”);
ms.show(100);
ms.show(“string”);
ms.show(0.999);

}

运行截图: 3.如果同时存在同名的函数，方法模版不会替换同名非模版方法。非模版方法是优先于模版方法的，相当于模版方法在该实例会被覆盖，这个会在下两篇中详细介绍。 例子:  

#include
#include
using namespace std;
template
class man{
private:
string name;
T data;
public:
man(const string &m,T d):name(m),data(d){
}
void show(int i)const{
cout<<”这里是非模版方法!!”<<endl;
cout<<”name=”<<name<<” ,data=”<<data<<endl<<endl;
}
template
void show(TT t)const{
cout<<”这里是模版方法:”<<endl;
cout<<”This is “<<t<<” vesion:”<<endl;
cout<<”name=”<<name<<” ,data=”<<data<<endl;
}

};
int main()
{
man m(“guang”,10);
m.show(100);
m.show(“string”);
m.show(0.999);

cout<<endl<<endl;
man ms(“jing”,”love”);
ms.show(100);
ms.show(“string”);
ms.show(0.999);

}

运行截图: —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

C++的模版有时候很可能无法处理某些类型。 例如：  

#include
using namespace std;
class man{
private:
string name;
int data;
public:
man(string s,int i):name(s),data(i){
}
void show()const{
cout<<”this name is “<<name<<” ,data=”<<data<<endl;
}
};
template
void mSwap(T t1,T t2){
T temp=t1;
t1=t2;
t2=temp;
cout<<”Here are template version “<<t1<<” and “<<t2<<” swap successed!”<<endl;

};
int main()
{
mSwap(88,66);
man m1(“guang”,99);
man m2(“jing”,10);
mSwap(m1,m2);
}

编译结果： 可以看到会出现很多错误。（虽然这不是重点。） 假设我希望mSwap只是交换两个man的data，而name还保持与原来一样。该怎么做呢？ 这个时候，就需要我们为特定的类型提供具体化的模版定义了。 具体化包括显式具体化以及隐式实例化和显式实例化。 1.显式具体化的原型和定义应以template<>开头，并通过名称来指出类型。  

template<>
void mSwap(man &m1,man &m2)

或者  

template<>
void mSwap(man &m1,man &m2)

  修改后的例子:  

#include
using namespace std;
class man{
private:
string name;
int data;
public:
man(string s,int i):name(s),data(i){
}
void show()const{
cout<<”this name is “<<name<<” ,data=”<<data<<endl;
}
void setData(int d){
data=d;
}
int getData()const{
return data;
}
};
template
void mSwap(T &t1,T &t2){
T temp=t1;
t1=t2;
t2=temp;
cout<<”Here are template version “<<t1<<” and “<<t2<<” swap successed!”<<endl;

};
template<>
void mSwap(man &m1,man &m2){
int temp=m1.getData();
m1.setData(m2.getData());
m2.setData(temp);
cout<<”Here are the man version,successed!”<<endl;
}
int main()
{
int i=88,j=66;
mSwap(i,j);
man m1(“guang”,99);
man m2(“jing”,10);
mSwap(m1,m2);
m1.show();
m2.show();
}

运行截图： 这就是模版显式具体化的作用了。 需要注意的是，具体化优先于常规模版，而非模版函数优先于具体化和常规模版。 2.实例化 要进一步了解模版，必须理解术语实例化和具体化。记住，在代码中包含函数模版本身并不会生成函数定义，它只是一个用于生成函数定义的方案。编译器使用模版为特定类型生成函数定义时，得到的是模版实例，例如，上面的mSwap(i,j),函数调用mSwap(i,j)导致编译器生成mSwap（）的一个实例，该实例使用int类型。 模版并非是函数定义，但使用int的模版实例是函数定义。这种实例化方式被称为隐式实例化。 C++还可以显式实例化。 语法为，声明所需的种类–用<>符号指示类型，并在声明之前加上关键字template: templata void mSwap(man &,man &) 该声明的意思是“使用mSwap()模版生成man类型的函数定义”。   —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

测试源码:

//测试派生类的构造函数的调用顺序何时调用
//Fedora20 gcc version=4.8.2
#include
using namespace std;

class base
{
public:
base()
{

cout<<”base created!”<<endl;
}
~base()
{
cout<<”base destroyed!”<<endl;
}
};
//公有继承
class A:public base
{
public:
A()
{
cout<<”A created!”<<endl;
}
~A()
{
cout<<”A destroyed!”<<endl;
}
};
class B:public A
{
public:
B()
{
cout<<”B created!”<<endl;
}
~B()
{
cout<<”B destroyed!”<<endl;
}
};

测试代码：

int main()
{
A a;
A *a1;
cout<<”可以看到a1并没有调用基类的构造函数”<<endl;
A *a2=new A;
//只有在new 一个对象的时候才会调用基类的构造函数
cout<<”可以看到a3也并没有调用基类的构造函数”<<endl;
A *a3=&a;

   B b;

}

输出为：   可以看到，在创建派生类的对象的时候，首先调用的是基类中的构造函数，然后才是调用派生类自己的构造函数。 而在析构的时候，顺序则刚好相反，先调用派生类的析构函数，然后才是调用基类的构造函数，这是因为对象创建时候对象存放在堆栈中的原因。（new 的对象虽然是存在堆中，但是在堆栈中依然存放其堆中的地址，因此，析构的时候也是一样） 那么，创建其对象的数组时:A a[2]，是否会调用其构造函数呢，这是肯定的，如下 测试代码：（仅修改main里面的内容）  

int main()
{
A a[2];
}

结果为： 那如果是创建指向其对象的数组呢? A *a[2];

int main()
{
A *a[2];
}

答案显然是不会。 那么这个时候，如果A里面有一个函数fun(),令a[0]->fun()会发生什么情况呢？  

void fun()
{
cout<<”A fun run”<<endl;
}

测试代码：  

int main()
{
A *a[2];
a[0]->fun();
}

结果为： 可以看到，虽然没有调用构造函数，但是依然可以使其执行其成员函数呢！ 那么，如果A有一个public int i;的变量，a[0]->i，会是什么？  

class A:public base
{
public:
int i;
A()
{
cout<<”A created!”<<endl;
}
~A()
{
cout<<”A destroyed!”<<endl;
}
void fun()
{
cout<<”A fun run”<<endl;
}
};

测试代码：  

int main()
{
A *a[2];
a[0]->fun();
cout<<endl<<a[0]->i<<endl;
}

结果： 可以看到，a[0]->i指向一个不确定的值！如果指定static const int i=1;那么，指向的必然就是1了。 今天就先测试这些最简单的吧，有点累了，多继承，虚基层明天再测试。 突然发现好像上次UC笔试做这道题的时候，析构的顺序似乎弄错了，郁闷。 还没收到面试信息，也还没有受到笔试挂了的通知，也不知道是个什么情况啊。 继续努力吧。 有时候，细节真的很重要！   —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

C++在对表达式求值时，会采用短路逻辑。 这意味着一旦最终结果可以确定，就不会对表达式剩余部分求值。 例如: bool  result=babb(i>0); 如果ba的值为true,整个表达式必然为true,因此不会对其他部分求值。  

#include
using namespace std;
int main()
{
int i=0;
//可以看到if语句遇到true就直接不执行后面的i++了，i++没有被执行
if(truei++)
cout<<”i=”<<i<<endl;//因此i=0
int j=0;
//因为第一个遇到的是false，所以继续向后执行，j++被执行
if(falsej++true)
cout<<”j=”<<j<<endl;//因此j=1

int r1=5>3?5:r1=10;//因为5>3值为bool,因此r1=10并没有被执行
cout<<”r1=”<<r1<<endl;
r1=5<3?5:r1=10;
cout<<”r1=”<<r1<<endl;

int a,b;
int result=0;
while(cin>>a>>b&&a!=0)
{
//可以从这里测试短路逻辑
int result=a>b?a:result=100;
cout<<”result=”<<result<<endl;
}
cin.get();
cin.get();
return 0;
}

短路逻辑可以阻止代码执行多余的操作，但是如果后面的表达式以某种方式影响程序，例如上面的，  

if(truei++)
cout<<”i=”<<i<<endl;//因此i=0

如果你是希望执行完之后i++，那么就会产生BUG,需要注意。

—————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

在C++里面，const关键字的用处很多，使用好const关键字对程序的健壮性大有好处。 首先来看看const一般都用在什么地方。 1.用于定义常量。    const用的最多的就是用来定义常量了。 const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误。    一个最简单的例子：  

#include
using namespace std;
int main()
{
const int i=5;
cout<<”i=”<<i<<endl;
//i=10;
//cout<<”i=”<<i<<endl;

};

这样运行时毫无问题的，但是如果你想给i重新赋值i=10的时候就会报错！ 2.让指针指向一个常量对象，这样可以防止使用该指针来修改所指向的值。 例如：

#include
#include
using namespace std;
int main()
{
int i=20;
const int* p=&i;//令p指向i,并且不能通过p修改i
cout<<*p<<” address:”<<p<<endl;
//*p=21;
i=15;
cout<<*p<<” address:”<<p<<endl;
};

const int* p=&i;该声明指出了p是一个指向const int的指针，因此不能使用p来修改这个值。

换句话说，*p的值为const，是不能修改的。

注意：这样就可以禁止通过p来修改i的值，例如*p=21这样的操作时不允许的。p的声明并不意味着它所指向的值就是一个const常量，而只是意味着对于p而言，这个值是const,但是这并不能说明i是一个不能修改的值，例如i=15,这样的操作时允许的。 并且，p指向的位置是可以改变的，例如：  

#include
#include
using namespace std;
int main()
{
int i=20;
const int* p=&i;
cout<<*p<<” address:”<<p<<endl;
//*p=21;
int k=15;
p=&k;
cout<<*p<<” address:”<<p<<endl;
};

运行结果： 可以看出，p所指向的地址已经改变了！ 3.将指针本身声明为常量，这样可以防止修改指针指向的位置。 例子：

#include 
#include 
using namespace std;
int main()
{
          int i=20;
         int\* const p=&i;//注意const的位置
cout<<\*p<<" address:"<
#include 
using namespace std;
int main()
{
   const int pos1=20;
   int pos2=20;
//pp1,pp2均是const int\*,但只有pos1是const
const int\* pp1=&pos1;
const int\* pp2=&pos2;

int \*p1=const\_cast(pp1);
int \*p2=const\_cast(pp2);
\*p1=15;
\*p2=15;
cout<<"pos1="<
    
    
	

		
		

			 
        		

        			C++
        		
      		 
        		

        			学习笔记
        		
      		
		
	

    
	

		
		

			 
        		

        			C++学习笔记
        		
      		
		
	


    
    

      展开全文 >>