using std:cin;    //这样就可以直接调用cin函数

#include<string>
using std::string;

string s1; //默认为空字符串
string s2(s1); //s2为s1的副本
string s3="liangzi"; //拷贝初始化
string s4(s3); //s4时s3的副本
string s4=s3;//与上一条指令等价
string s5("liangzi");//直接初始化
string s6(100,'cc'); //将cc重复100遍得到的字符串

os<<s   //将s中的字符串写到输出流os之中，返回os
is>>s //与上一条指令相似，将输入的字符串存储到s之中
is=getline(is, s)   //该函数将从is中读取一行赋值给s，之后返回is
s.empty()  // 判断字符串是否为空
s.size()  //返回字符串中字符的个数
s[n]   //返回字符串中的第n个字符，从0开始
s1+s2 //两个字符串进行连接
s1==s2 //二者完全一致
<, <=, >, >= //利用字符在字典中的顺序进行比较

int main()
{
    string s;
    cout << "please input a string" << endl;
    cin >> s;
    cout << s << endl;
    return 0;
}

int main()
{

//使用C++读取文本文件的示例
    string file_path, line;
    fstream read_file;  //文件流类型，以后会详细介绍
    cout << "please input the need read path" << endl;
    cin >> file_path;
    read_file.open(file_path);
    while (!read_file.eof())
    {
        getline(read_file,line);
        cout << line << endl;
    }
    read_file.close();
    system("pause");
    return 0;
}

string s1="liangzi", s2="zuishuai";
string ss=s1+s2;                                //正确
string sss=s1+"---------->>"+s2;         //正确
string ssss="liangzi"+"zuishuai";       //错误

#incldue<cctype>
using std::cctype;

isalnum(c)  //当c为字母或者数字时为真
isalpha(c)  //当c为字母时为真
iscntrl(c)   //当c为控制字符时为真
isdigit(c)   //当c为数字时为真
isgraph(c) //当c不是空格但是可以打印时为真
islower(c) //当c是小写字母时为真
isprint(c)  //当c是可打印字符时为真
ispunct(c)  //当c是标调符号时为真
isspace(c)  //当c是空白时为真
isupper(c)  //当c为大写字母时为真
isxdigit(c)  //当c是十六进制数字时为真
tolower(c)  //若c为大写字母，将其变为小写字母，否则不变
toupper(c) //若c为小写字母，将其变为大写字母，否则不变

//例如，输出一个字符串的每一个字符
sting s("liangzid");
for(auto i:s)
{
    cout<<i<<endl;
}

string s("liangzi zi zui shuai ! ");
i=0;
for (auto &c:s)
{
    if (ispunct(c))
    {
        ++i;
    }
}
cout<<" the number of punctuation characters is : "<<i<<endl;

vector<Type> v1       //v1是一个空的容器，执行Type类型的默认初始化
vector<Type> v2(v1)  //v2是v1的副本
vector<Type> v3=v1  //直接初始化
vector<Type> v4(n,val)  //v4包括了n个重复的均为val的元素
vector<Type> v5{a,b,c,...}  //v5中容纳的元素包括a,b,c,...
vector<Type> v6={a,b,c,...}//同上

//示例：初始化一个数列，里面储存着从0到99的整数
vector<int> sequence;
for(int i=0;i !=100;i++)
{
    sequence.push_back(i);
}

//使用示例：将之前读取的没一行作为一个元素，实现对任何不定长文件的动态储存。
int main()
{
   string file_path, line;
   fstream read_file;
   vector<string> all_lines;
   cout << "please input the need read path" << endl;
   cin >> file_path;
   read_file.open(file_path);
   while (!read_file.eof())
   {
   	getline(read_file,line);
   	all_lines.push_back(line);
   }
   read_file.close();
   system("pause");
   return 0;
}

int main()
{
    string file_path, line;
    fstream read_file;
    vector<string> all_lines;
    cout << "please input the need read path" << endl;
    cin >> file_path;
    read_file.open(file_path);
    while (!read_file.eof())
    {
        getline(read_file,line);
        all_lines.push_back(line);
    }
    read_file.close();
    for (auto &cc : all_lines)
    {
        cout << cc << endl;
    }
    system("pause");
    return 0;
}

vector<int> liangzi{1,2,3,4,5};
auto begin_liangzi=liangzi.begin();
auto end_liangzi=liangzi.end();
//之所以使用auto，是因为我们也不确定到底其指定的是什么类型

//通过以下运算符可以看出迭代器和指针的类似之处

*iter                                   //返回迭代器iter所指向元素的引用
iter->mem                        //解引用iter并获取该元素的名为mem的成员，等价于(*iter).mem
++iter                                 //令iter指向容器中的下一个元素
--iter                                 //令iter指向容器中的上一个元素
iter1==iter2                //若相等，指它们指向了容器中的同一个元素
iter1 != iter2                  //同上 

int i=100;      //不是常量表达式
constexpr int ii=100;
int array1[100];                       //正确
int *parray[100];                      //正确，数组中的每个元素都是指向整型数据的指针
string array2[i];                      //错误
string array3[ii];                        //正确

int a[ ]={1,2,3};
int aa[ ]=a;            //错误

int &liangzi[100]={1,2,3,...};                //错误，引用不是一个对象，不能被数组储存

int *pliangzi[100];                          //正确，数组中的每个圆度都是指针
int (*pliangzii)[100]=&array1;                   //正确，定义了一个指针，指向一个有100个元素的数组
int (&liangzia)[100]=array;                      //正确，是对一个数组的引用

/* 可以记住一句口诀：从右向左，从内向外*/