string 转int
string str=”123”;
int i;
i=atoi(str.c_str());

  cin.getline()输入最后会自动丢弃回车符 cin.clear()是不会清除最后的回车符的 如果想清楚最后那个回车符,必须调用一次cin.get()!   关于模板类： 错误 1 error C2955: “List”: 使用类 模板 需要 模板 参数列表 e:\c++\number10\number10\list.cpp61number10 template class List{/**/} cpp实现： template List::List() //模板类的定义必须有模板参数,不能写出List::List!! { front=rear=nullptr; qsize=0; }   关于char []里面的元素个数 char a[5]={1,2,3}; sizeof(a)=5; strlen(a)=3;   函数后的const 表明此函数不能影响对象的状态，说白一点就是
不会改变对象中成员变量的数值。   关于返回this String &operator=(const String &st) { if(this==&st)//this的应用 return *this;//不能写成return this,*this才是对象，this只是一个引用 } 关于派生类调用父类方法，用域运算符：：   关于派生类调用父类的友元函数： friend ostream&operator<<(ostream &os,const baseDMA &bd) { os<<”This is baseDMA:  “; os<<(const  DMA &)bd;//通过强制类型转换调用基类友元函数 //os<<”label:”<<rs.label<<”   rating:”<<rs.rating<<endl; return os; }   throw 指针问题 class A{..} throw (new A()); catch(A  *a);   peek()返回下一个字符，但不抽取流中字符   静态变量是不如栈的。

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

众所周知，C++里面访问控制符有public,protected,private;当然，我这里就不讨论friend（友元函数）了。 在本类中就不用讨论了，因为在本类中，类的所有成员对于本类来说都是可见的。 下面先来看一下不同访问修饰符修饰的类的成员属性在类外可见的情况。  

#include
using namespace std;
/*
类A有三个成员属性，分别是k,i,j,str,以及一些方法;
访问修饰如下：
pubic:
int k;
private:
int i;
protected:
string str;
*/
class A{
public:
int k;
A(int kk,int ii,string s){
k=kk;
i=ii;
str=s;
}
void showPublic(){
cout<<”this is public!”<<endl;
}
private:
int i;
void showPrivate(){
cout<<”this is private!”<<endl;
}

protected:
string str;
void showProtected(){
cout<<”this is protected!”<<endl;
}
};
/*
检测A中的成员属性k,j,str在类外（非派生类）是否可见
*/
int main()
{
A a(1,2,”OH”);
int k=a.k;//检测public修饰的属性在类外是否可见
cout<<k<<endl;
int i=a.i;//检测private修饰的属性在类外是否可见
cout<<i<<endl;
string s=a.str;//检测protected修饰的属性在类外是否可见
cout<<s<<endl;

}

编译结果为： 由此可见，在类外仅有public修饰的成员可见，而protected和private修饰的成员属性是不可见的，同样的，对于成员方法而言，也是一样的。  

//A定义不变

int main()
{
A a(1,2,”OH”);
a.showPublic();
a.showProtected();
a.showPrivate();
}

编译结果：   由此可见，成员方法和成员属性也是一样的，因为两者都是属于类的成员！因此访问规则都是一样的。

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

现在来看一下private,protected,public修饰的成员属性在公有派生类中的可见情况。

#include
using namespace std;
/*
类A有三个成员属性，分别是k,i,j,str,以及一些方法;
访问修饰如下：
pubic:
int k;
private:
int i;
protected:
string str;
*/
class A{
public:
int k;
A(int kk,int ii,string s){
k=kk;
i=ii;
str=s;
}
void showPublic(){
cout<<”this is public!”<<endl;
}
private:
int i;
void showPrivate(){
cout<<”this is private!”<<endl;
}

protected:
string str;
void showStr(){
cout<<”str=”<<str<<endl;
}
void showProtected(){
cout<<”this is protected!”<<endl;
}
};
//公有继承
class B:public A
{
public:
B(int i,int j,string s):A(i,j,s){

}
void showMethod(){
A::showPublic();
A::showPrivate();
A::showProtected();
}
void showAttr()
{
cout<<A::k<<endl;
cout<<A::i<<endl;
cout<<A::str<<endl;
}

};
int main()
{
B b(1,2,”hello”);
b.showMethod();
b.showAttr();

}

编译结果为： 由此可见，对于公有继承而言，基类的protected和public成员都是可见的。并且，使用公有继承，基类的公有成员将变为派生类的公有成语，基类的保护成员将变成派生类的保护成员，基类的私有成员将变为派生类的私有成员，可以通过下面的例子测试：  

#include
using namespace std;
/*
类A有三个成员属性，分别是k,i,j,str,以及一些方法;
访问修饰如下：
pubic:
int k;
private:
int i;
protected:
string str;
*/
class A{
public:
int k;
A(int kk,int ii,string s){
k=kk;
i=ii;
str=s;
}
void showPublic(){
cout<<”this is public!”<<endl;
}
private:
int i;
void showPrivate(){
cout<<”this is private!”<<endl;
}

protected:
string str;
void showStr(){
cout<<”str=”<<str<<endl;
}
void showProtected(){
cout<<”this is protected!”<<endl;
}
};
//公有继承
class B:public A
{
public:
B(int i,int j,string s):A(i,j,s){

}
/*
void showMethod(){
A::showPublic();
A::showPrivate();
A::showProtected();
}
void showAttr()
{
cout<<A::k<<endl;
cout<<A::i<<endl;
cout<<A::str<<endl;
}
*/
};
int main()
{
B b(1,2,”hello”);
b.showPublic();
b.showProtected();
b.showPrivate();

}

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

现在来看一下private,protected,public修饰的成员属性在保护继承的派生类中的可见情况。  

#include
using namespace std;
/*
类A有三个成员属性，分别是k,i,j,str,以及一些方法;
访问修饰如下：
pubic:
int k;
private:
int i;
protected:
string str;
*/
class A{
public:
int k;
A(int kk,int ii,string s){
k=kk;
i=ii;
str=s;
}
void showPublic(){
cout<<”this is public!”<<endl;
}
private:
int i;
void showPrivate(){
cout<<”this is private!”<<endl;
}

protected:
string str;
void showStr(){
cout<<”str=”<<str<<endl;
}
void showProtected(){
cout<<”this is protected!”<<endl;
}
};
//保护继承
class B:protected A
{
public:
B(int i,int j,string s):A(i,j,s){

}

void showMethod(){
A::showPublic();
A::showPrivate();
A::showProtected();
}
void showAttr()
{
cout<<A::k<<endl;
cout<<A::i<<endl;
cout<<A::str<<endl;
}

};
int main()
{
B b(1,2,”hello”);
b.showMethod();
b.showAttr();
/*
b.showPublic();
b.showProtected();
b.showPrivate();
*/
}

编译结果为： 这个结果看似和public继承是一样，那么，是否其他的也是一样的呢？看下面的测试：尝试在派生类外直接访问基类成员  

#include
using namespace std;
/*
类A有三个成员属性，分别是k,i,j,str,以及一些方法;
访问修饰如下：
pubic:
int k;
private:
int i;
protected:
string str;
*/
class A{
public:
int k;
A(int kk,int ii,string s){
k=kk;
i=ii;
str=s;
}
void showPublic(){
cout<<”this is public!”<<endl;
}
private:
int i;
void showPrivate(){
cout<<”this is private!”<<endl;
}

protected:
string str;
void showStr(){
cout<<”str=”<<str<<endl;
}
void showProtected(){
cout<<”this is protected!”<<endl;
}
};
//保护继承
class B:protected A
{
public:
B(int i,int j,string s):A(i,j,s){

}
/*
void showMethod(){
A::showPublic();
A::showPrivate();
A::showProtected();
}
void showAttr()
{
cout<<A::k<<endl;
cout<<A::i<<endl;
cout<<A::str<<endl;
}
*/
};
int main()
{
B b(1,2,”hello”);
/*
b.showMethod();
b.showAttr();
*/
b.showPublic();
b.showProtected();
b.showPrivate();

}

编译结果为： 可以看到，基类的public成员也不能直接访问了！而在public继承中，时可以在类外直接访问基类的public成员的！ 这是为什么？原因是使用保护继承时，基类的公有成员和保护成员都会变成派生类的保护成员。这就是保护继承和公有继承的最主要区别。貌似其他的木有区别0.0。 —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

最后来看一下private,protected,public修饰的成员属性在私有派生类中的可见情况。  

#include
using namespace std;
/*
类A有三个成员属性，分别是k,i,j,str,以及一些方法;
访问修饰如下：
pubic:
int k;
private:
int i;
protected:
string str;
*/
class A{
public:
int k;
A(int kk,int ii,string s){
k=kk;
i=ii;
str=s;
}
void showPublic(){
cout<<”this is public!”<<endl;
}
private:
int i;
void showPrivate(){
cout<<”this is private!”<<endl;
}

protected:
string str;
void showStr(){
cout<<”str=”<<str<<endl;
}
void showProtected(){
cout<<”this is protected!”<<endl;
}
};
//私有继承
class B:private A
{
public:
B(int i,int j,string s):A(i,j,s){

}

void showMethod(){
A::showPublic();
A::showPrivate();
A::showProtected();
}
void showAttr()
{
cout<<A::k<<endl;
cout<<A::i<<endl;
cout<<A::str<<endl;
}

};
int main()
{
B b(1,2,”hello”);
/*
b.showMethod();
b.showAttr();

b.showPublic();
b.showProtected();
b.showPrivate();
*/
}

编译结果： 结果和前面的都是一样的。那么在派生类类外的可见性呢？ 测试例子：  

#include
using namespace std;
/*
类A有三个成员属性，分别是k,i,j,str,以及一些方法;
访问修饰如下：
pubic:
int k;
private:
int i;
protected:
string str;
*/
class A{
public:
int k;
A(int kk,int ii,string s){
k=kk;
i=ii;
str=s;
}
void showPublic(){
cout<<”this is public!”<<endl;
}
private:
int i;
void showPrivate(){
cout<<”this is private!”<<endl;
}

protected:
string str;
void showStr(){
cout<<”str=”<<str<<endl;
}
void showProtected(){
cout<<”this is protected!”<<endl;
}
};
//私有继承
class B:private A
{
public:
B(int i,int j,string s):A(i,j,s){

}
/*
void showMethod(){
A::showPublic();
A::showPrivate();
A::showProtected();
}
void showAttr()
{
cout<<A::k<<endl;
cout<<A::i<<endl;
cout<<A::str<<endl;
}
*/
};
int main()
{
B b(1,2,”hello”);
/*
b.showMethod();
b.showAttr();
*/
b.showPublic();
b.showProtected();
b.showPrivate();

}

编译结果： 编译结果跟保护继承是一样的，是否说两者规则一样呢？答案当然是否定的。 使用私有继承时，基类的公有成员和保护成员都将成为派生类的私有成员！也就是说，使用私有继承时，第三代继承类将不能使用基类的接口(即public类成员),私有继承和保护继承的区别正是在此！ 测试例子：  

#include
using namespace std;
/*
类A有三个成员属性，分别是k,i,j,str,以及一些方法;
访问修饰如下：
pubic:
int k;
private:
int i;
protected:
string str;
*/
class A{
public:
A(){}
void showPublic(){
cout<<”this is public!”<<endl;
}
};
//私有继承
class B:private A
{
public:
B(){

}
};
class C:public B
{
public:
C(){}
};
int main()
{
C c;
c.showPublic();

}

编译结果： 结果正好印证了上面的结论。

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

各种继承方式:

特征

公有继承

保护继承

私有继承

公有成员变为

派生类的公有成员

派生类的保护成员

派生类的私有成员

保护成员变为

派生类的保护成员

派生类的保护成员

派生类的私有成员

私有成员变为

只能通过基类接口访问

只能通过基类接口访问

只能通过基类接口访问

能否隐式向上转换

能

能（但只能在派生类中）

不能

要点： 对于公有继承：基类的protected和public成员都是可见的。并且，使用公有继承，基类的公有成员将变为派生类的公有成语，基类的保护成员将变成派生类的保护成员，基类的私有成员将变为派生类的私有成员。 对于保护继承：使用保护继承时，基类的公有成员和保护成员都会变成派生类的保护成员。这就是保护继承和公有继承的最主要区别。 对于私有继承：私有继承时，基类的公有成员和保护成员都将成为派生类的私有成员！也就是说，使用私有继承时，第三代继承类将不能使用基类的接口(即public类成员),私有继承和保护继承的区别正是在此！

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

C++中结构体和C中有点不同的就是，C++中的结构体可以有类似于类那样的方法。

#include
using namespace std;
struct Point{
int i;
int j;
Point(int ii,int jj){//类似于类的构造函数
i=ii;
j=jj;
str=”Point(int,int)”;
}
Point(){
str=”Point()”;
}
Point(int ii){
i=ii;
str=”Point(int)”;
}

int getI(){//类似于类的成员函数
return i;
};
string getStr(){
return str;
}
private://可以通过类似于类的访问控制符来修饰
string str;
};
int main()
{

Point p;//必须有相对应的构造函数，姑且称之为构造函数吧
p.i=1;
p.j=2;
//p.str=”stringOne”;//不能直接符访问
string s=p.getStr();
cout<<s<<endl;
int k=p.getI();
cout<<k<<endl;
Point pp(3,4);
int kk=pp.getI();
cout<<kk<<endl;

Point ppp(5);
int kkk=ppp.getI();
cout<<kkk<<endl;
ppp.i=15;
kkk=ppp.getI();
cout<<kkk<<endl;
}

执行结果： 区别在于：结构体中的成员的默认访问属性都是public，而在类中则是private: 也可以利用默认初始化器的方式初始化，例如：

Point(int ii):i(ii){
//i=ii;
str=”Point(int)”;
}

这样也是可以的。  

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

在早期的C++中，如果需要一些接受一些参数的构造函数，同时需要一个不接收任何参数的默认构造函数，就必须显示地编写空的默认构造函数.例如：  

//tc.h

class A{
private:
int i;
public:
A(){};
A(int ii)；
};

但最好就是接口和声明分离，那么就是如下的定义  

//tc,h
class A{
private:
int i;
public:
A();
A(int ii)；
};

这样，就必须在实现中给出空参数构造函数的实现：  

#include
#include “tc.h”
using namespace std;
A::A(){//必须给出其实现
};
A::A(int ii){
i=ii;
}
void A::show()const{
std::cout<<”this is A object!”<<std::endl;
};
int main()
{
A a;
a.show();
}

为了避免手动编写空默认构造函数，C++11引入了显示默认构造函数的概念，从而只需在类的定义中编写空默认构造函数而不需要在实现文件中提供其实现：  

//tc.h
#ifndef tc_h_
#define tc_h_
class A{
private:
int i;
public:
A()=default;//default
A(int ii);
void show()const;
};
#endif

//tc.cpp
#include
#include “tc.h”
using namespace std;
/*
A::A(){//不必给出其实现
};
*/
A::A(int ii){
i=ii;
}
void A::show()const{
std::cout<<”this is A object!”<<std::endl;
};
int main()
{
A a;
a.show();
}

编译以及执行结果： 同样的，C++还支持显式删除构造函数的概念。例如，你想定义一个类，这个类没有任何的构造函数，并且你也不想让编译器自动生成一个默认的空参数的构造函数，那么你就可以显式地删除默认构造函数。  

//tc.h
#ifndef tc_h_
#define tc_h_
class A{
private:
int i;
public:
A()=delete;//delete
void show()const;
};
#endif

//tc.cpp
#include
#include “tc.h”
using namespace std;
/*
A::A(){//必须给出其实现
};

A::A(int ii){
i=ii;
}*/
void A::show()const{
std::cout<<”this is A object!”<<std::endl;
};
int main()
{
A a;
a.show();
}

编译结果： 可以看到，默认构造函数被删除了，那么，能不能删除一些其他的带参数构造函数呢？ 其实这个问题有点多余，因为如果你不想要这个构造函数，你不定义这个带参的构造函数就OK了！        

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

在构造体内初始化数据成员是最常见的方法。

例如：

#include
using namespace std;
class A
{
private:
int i;
string s;
public:
A(int ii,string ss){
//在构造函数体内初始化数据成员
i=ii;
s=ss;
cout<<”ctor:i=”<<i<<”,s=”<<s<<endl;
}
/*
不要写成
A(int i,int j){
i=i;//在这里面,起作用的i是局部域内的i,而不是类的成员i
j=j;
}
//编译虽然不会错，但是你可以运行一下试试
*/
void show()const{
cout<<”i=”<<i<<”,s=”<<s<<endl;
}
};
int main()
{
A a(5,”str”);
a.show();
}

C++还提供了一种叫做构造函数初始化器的方法初始化数据成员。

#include
using namespace std;
class A
{
private:
int i;
string s;
public:

A(int ii,string ss):i(ii),s(ss){
//利用构造函数初始化器初始化数据成员
cout<<”ctor:i=”<<i<<”,s=”<<s<<endl;
}
/*
//利用构造函数初始化器初始化数据成员可以写成这样
//具体原因请看两者的区别
A(int i,string s):i(i),s(s){

cout<<”ctor:i=”<<i<<”,s=”<<s<<endl;
}
*/
void show()const{
cout<<”i=”<<i<<”,s=”<<s<<endl;
}
};
int main()
{
A a(7,”构造函数初始化器”);
a.show();
}

编译以及运行结果为：     构造函数初始化器出现在构造函数参数列表以及构造函数开花括号之间，以冒号开始，逗号分割。 列表中每个元素都使用函数符号或者调用超类构造函数初始化某个数据成员。调用超类构造函数的例子如下：  

class B:public A
{
private:
int j;
public:
B(int i,int j,string s):A(i,s),j(j){
//A（i,s）调用A类中的构造函数
}

};

使用构造函数初始化数据成员与在构造函数体内初始化数据成员是不同的。 当C++创建某个对象时，必须在调用构造函数前创建该对象的所有数据成员。如果数据成员本身就是一个对象，那么在创建这些数据成员时，必须为其调用构造函数。当在构造函数体内给某个对象赋值时，并没有真正创建这个对象，而是改变对象的值。 而使用构造函数初始化器则是在创建数据成员的时候赋初值，这样做比前者效率更好。 关于构造函数初始化器要注意的一点是：初始化数据成员的顺序是按照类的定义出现顺序，而不是按照构造函数初始化器中的顺序。 可以做一个简单的测试测试在构造函数体内赋值时的数据成员的初始值情况。  

#include
using namespace std;
class A
{
private:
int i;
string s;
public:

A(int ii,string ss){
cout<<”before ctor:i=”<<i<<”,s=”<<s<<endl;//使用构造函数初始化数据成员之前
i=ii;
s=ss;
cout<<”after ctor:i=”<<i<<”,s=”<<s<<endl;//使用构造函数初始化数据成员之后

}
void show()const{
cout<<”i=”<<i<<”,s=”<<s<<endl;
}
};
int main()
{
A a(7,”构造函数初始化器”);
a.show();
}

结果为： 有些人喜欢在构造函数体内初始化数据成员，但是有些数据类型必须在构造函数初始化器中初始化。 1：const数据成员     原因是const成员创建之后无法对其赋值！必须在创建的时候提供初始值。 2.引用数据对象    如果不指向一个量，引用将无法存在 3.没有默认构造函数的对象数据成员   当调用该对象数据成员的默认构造函数初始化成员对象时，无法找到默认构造函数。 4.没有默认构造函数的超类。   类似于3。 —————————————————————————————————————————————————— //写的错误或者不好的地方请多多指导，可以在下面留言或者给我发邮件，指出我的错误以及不足，以便我修改，更好的分享给大家，谢谢。 转载请注明出处：https://www.royalchen.com/ author:royalchen Email:royalchen@royalchen.com ———————————————————————————————————————————————————

C++11中的初始化列表构造函数(Initialize_list Constructors)是将std::initializer_list作为第一个参数的构造函数，并且没有任何其他参数（或者其他参数具有默认值）。例如：  

#include
#include <initializer_list>//必须包含该头文件
#include
using namespace std;
class A
{
private:
vector myVector;
public:
//参数为initializer_list args
A(initializer_list args){
for(auto iter=args.begin();iter!=args.end();++iter)
myVector.push_back(*iter);

}
A(const A &)=delete;
void showVector(){
for(auto citer=myVector.cbegin();citer!=myVector.cend();++citer)
std::cout<<*citer<<” “;
cout<<endl;
}
};
int main()
{

A a={1,2,3,4,5,6,7,8,9,10,11,12};
//不能写成A a(1,2,3,4,5,6,7,8,9,10,11,12);
//a.show();
a.showVector();
}

使用前请查看你的编译器是否支持该C++11特性.我的是GCC C++ 4.8.2完美支持。 编译时请附加特性-std=c++11 编译及运行结果。 有其他参数的情况  

//ti2.cpp

#include 
#include //必须包含该头文件
#include 
using namespace std;
class A
{
private:
vector myVector;
string str;
public:
//参数为initializer\_list args
A(initializer\_list args,string s="initailizer\_list"){
for(auto iter=args.begin();iter!=args.end();++iter)
myVector.push\_back(\*iter);
//i=ii;//i必须有默认值，并且其实这一句没用
str=s;//看后面的，因此这个默认值应该是类内成员初始化
//即定义时赋予初始值:string str="initailizer\_list"
//不能写成A a={1,2,3,4,5,6,7,8,9,10,11,12.5,55，“is this word!”};
}
A(const A &)=delete;
void showVector(){
for(auto citer=myVector.cbegin();citer!=myVector.cend();++citer)
std::cout<<\*citer<<"  ";
cout<
    
    
	

		
		

			 
        		

        			学习笔记
        		
      		
		
	

    
	

		
		

			 
        		

        			C++学习笔记
        		
      		
		
	


    
    

      展开全文 >>