C++系列学习总结（二）

可见性

class Entity
{
//所有人都能访问X
public:
    int X;
//只有在Entity类中才能访问Y
private:
    int Y;
//只有在Entity及子类中能访问Z
protect:
    int Z;
}

数组

C++数组表示一堆变量的集合。
在栈上定义数组非常简单，int stu[10];获取数组内容可以直接用数组名【index】，它的生存周期为到花括号就自动销毁。
在堆上创建数组int* ptr=new int[10]，直到程序销毁之前，都是处于活动状态，所以要用delete关键词删除，delete[] ptr;
如果用指针指向该数组，int* ptr=stu，指针ptr指向的是数组的首地址，用指针获取数组内容为*(ptr+i)。

字符串

字符串：由双引号括起来的零个或多个字符构成，实际上是由常量字符构成的数组，编译器在每一个字符串后面添加\0，因此字符串的实际长度比内容多1.

字符串的基本功能

操作	作用
insert(pos, args)	在 pos 之前插入 args 指定的字符
erase(pos, len)	删除从 pos 开始的 len长度的字符。如果 len 为空，则删除 pos 后面的所有字符。
assign(args)	将字符串中的字符替换为指定字符。
append(args)	将指定字符串添加到字符串后面。
replace(range,args)	将字符串中的range范围内的字符串替换为指定字符串
find(agrs)	查找字符串中第一个出现的位置
rfind(args)	查找字符串中最后一次出现的位置
to_string(val)	将数值val替换为string类型并返回
substr(pos,n)	从pos开始，提取连续的n个字符
reverse(array.begin(),array,end())	反转字符串
strlen(array)	求字符串长度
strcmp(array0,array1)	比较字符串字符大小
strcpy(array0,array1)	将array1赋值给array0
empty(array0)	判断字符串是否为空
front()	取字符串第一个字符
back()	取字符串最后一个字符

字符串相加

//方法一
string name=string("zhangwei")+"snake";
//方法二
string name="zhangwei";
name += "snake";

const

const意味着声明的是一个常量而不是变量，不能改变const声明的常量。
1、当使用const定义指针时，const int* prt=new int;当const在之前，则可以对指针本身重新赋值，指向别的内容，但是不能修改指针指向地址的内容。
2、当const在之后，int* const prt=new int;，指针可以修改指针指向地址的内容 ，但是不能对指针本身重新赋值，指向别的内容。
3、在类中定义const

class Entity
{
public:
   int X,Y;
   int GetX() const{ return X;}

在方法名之后加上const，表明这个方法只能读取成员，而不能修改，即int GetX() const{ X="abc";return X;}会报错。
如果你一根筋非要在const定义的方法中修改变量，则可以使用mutable关键字。

class Entity
{
public:
    int X,Y;
    mutable int Z;
    int GetX() const{Z=3;return Z;}

mutable

mutable是允许函数是常量方法，但可以修改变量。

构造函数初始化列表

1、无参的构造函数
2、接受参数的构造函数

class Entity{
public:
    int X,Y;
    Entity(const int& x){}
    Entity(){}
    Entity():X(1),Y(2){}//在构造函数后加冒号直接对成员进行初始化
    //需要注意的是要按照成员定义的顺序写，如先写X，再初始化Y
       
}

三元运算符

A op B？C：D；
A op B为真则进行C，A op B为假则进行D

new

new在C++中用于申请动态存储空间，意思就是在堆中创建变量。

//使用new申请一个兑现
int* ptr=new int;
//使用new申请数组
int* arr=new int[10];

new通常搭配delete使用，delete用来释放存储空间。

//释放一个对象
delete ptr;
//释放数组
delete[] arr;

隐式构造函数

class Entity
{
pubilc: 
   int X;
   string name;
   Entity(const int& x):X(x),name("snake"){}
}
int main(){
//这是一般的构建对象
     Entity X(1);
//隐式构造对象，因为Entity构造函数接受int数值，将1转化为Entity，再赋值给X对象。
     Entity X=1;

#include<iostream>
using namespace std;
class Entity
{
public:
	int Id;
	string Name;
	Entity(const int& id) :Id(id), Name("snake") {}
	Entity(const string& name) :Id(2), Name(name) {}
};
int main() {
	Entity one = 2;
	Entity two = "snake";
}

在上述代码中，如果将snake赋值给two对象，会报错。
因为在编译器中，只支持一次隐式转换，而Entity two=“snake”中snake需要从const char类型转化为string类型再转化为Entity类型。所以将string类型赋值给对象时需要Entity two=string("snake");或"Entity two=Entity("snake");

explicit

explicit禁止隐式转换，将explicit添加到构造函数之前，意味着如果要使用整数构造这个Entity对象，则必须显式的调用此构造函数，用来防止意外转换。