《C&C++》学习记录

大一的时候学习的C&C++，那时候记得笔记也不多，就把我认为有用的保存下来，和大家分享下。

常用函数

1.1 iostream 文件库

//string类型中输入空格
//方法一
#include<iostream>
#include<string>
using namespace std;

int main()
{
    string s;
    getline(cin, s);

    cout<<s<<endl;
    return 0;
}
// 使用getline输入空格，需包含<string>头文件

//方法二
#include<iostream>
using namespace std;

int main()
{
    char s[10];
    cin.getline(s,10);
    cout<<s;
    return 0;
}
//实际接收参数为9个，最后一个为’\0‘终止符留出空间

1.2 math.h 文件库

1.次方函数：pow(3.14,5)    //3.14的5次方
2.绝对值函数：fabs(-9)  //-9的绝对值
3.atoi：字符串类型转换为int型，用法：atoi(数组)；
4.atof：字符串类型转换为float型，用法：同上

1.3 string 文件库

string a;   //定义a字符串
1.int b = a.length();  //返回字符串a的长度
2.int b = atoi(a.c_str());  // c_str()转换到第一个非数字字符为止
2.1-> c_str()返回的是一个临时指针，不能对其进行操作

1.4 string 函数库

构造函数：
1.string s; // 声明一个s字符串，为空

2.string s(ss); // 声明一个s字符串，将ss字符串复制过来

3.string s(ss,2); // 声明一个s字符串，将ss字符串从2位置（也就是第三个字符）后的所有字符复制过来

4.string s(ss,1,3); // 声明一个s字符串，将ss字符串从1位置（也就是第二个字符）起的3个字符复制过来

5.string s(chars); // 声明一个s字符串，将C字符串复制过来

6.string s(chars,5); // 声明一个s字符串，将C字符串的前5个字符复制过来

7.string s(6,char); // 声明一个s字符串，初值为6个char类型的字符，比如char为'a'，则s为aaaaaa

析构函数：

1.s.~string(); // 将s字符串析构

赋值函数：
1.string s=c; // 赋值函数，c既可以是字符串，也可以是C字符串，比如char a[]=“123”

2.s.assign(ss); // 赋值函数，ss既可以是字符串，也可以是C字符串

3.s.assign(ss,1,3); // 赋值函数，ss无论是string字符串还是C字符串，均从1位置开始的3个字符赋值

4.s.assign(ss,1); // 赋值函数，ss若为string字符串，则从1位置开始的所有字符赋值；若ss为C字符串，则赋值前1个字符

5.s.assign(6,char); //赋值函数，赋为6个char类型的字符

6.s.assign(s1.begin(),s1.end()-1); //赋值函数，将s1字符串从开始到倒数第二个字符赋值给s，string有begin和end，C字符串没有哦

操作函数：

1.swap(s1,s2); // 交换两个字符串

2.s.size(); // 返回字符串字符个数

3.s.length(); // 返回字符串字符个数

4.s.clear(); // 清除所有字符

5.s.empty(); // 返回字符串是否为空，若空则true，非空则false

6.s.begin(); // 字符串迭代器-开始位置

7.s.rbegin(); // 字符串迭代器-逆向开始位置，逆向开始是跳过结束符的第一个字符

8.s.end(); // 字符串迭代器-结束位置，注意结束一般是'\0'

9.s.rend(); // 字符串迭代器-逆向结束位置

10.s.capacity(); // 返回已分配存储的大小

11.s.resize(n); // 把字符串的长度设置为n个字符，若s字符串原本为1234，n为2，则resize后的s字符为12

12.s.max_size(); // 返回字符串的最大大小

13.s.capacity(); // 保留一定量内存以容纳一定数量的字符

14.s.at(5); // 输出s字符串5位置的字符（第六个字符）

15.getline(cin,s); // 获取一行字符串给s

16.s.copy(cs,3,2); // 将s字符串第二个字符后的三个字符，复制到C字符串cs的前三个字符的位置，原字符被替换掉，cs只能是C字符串

17.s.c_str(); // 将内容以C_string返回

18.s.data(); // 将内容以字符数组形式返回，和c_str()输出基本一致，区别在于data()结尾不补\0，毕竟是数组形式

添加函数：

1.s+=s1; // 添加函数，直接添加字符串至后方，s1可以是string字符串也可以是C字符串

2.s.append(ss); // 添加函数，将ss添加到后方

3.s.append(ss,1,3); // 添加函数，ss无论是string字符串还是C字符串，均将从1位置开始的3个字符添加

4.s.append(ss,1); // 添加函数，ss若为string字符串，则将从1位置开始的所有字符添加；若ss为C字符串，则添加前1个字符

5.s.append(6,char); //添加函数，添加6个char类型的字符

6.s.append(s1.begin(),s1.end()-1); //添加函数，将s1字符串从开始到倒数第二个字符添加到s后面，string有begin和end，C字符串没有哦

插入函数：

1.s.insert(2,ss); // 插入函数，在s字符串的第二个字符后插入ss

2.s.insert(2,ss,4); // 插入函数，若ss为string字符串，则在s字符串的第二个字符后插入ss的前四个字符；若ss为C字符串，则在s字符串的第二个字符后插入ss第四个字符后的所有字符

3.s.insert(2,ss,4,2); // 插入函数，s字符串的第二个字符后插入ss第四个字符后的2个字符

4.s.insert(2,6,char); //插入函数，s字符串的第二个字符后6个char类型的字符

5.s.insert(s.begin()+3,'A'); // 插入函数，通过迭代器在s字符串第三个字符后添加1个A字符

6.s.insert(s.begin()+3,6,'A'); // 插入函数，通过迭代器在s字符串第三个字符后添加6个A字符

7.s.insert(s.begin()+3,ss.begin(),ss.end()); // 插入函数，通过迭代器在s字符串第三个字符后添加ss字符串从开始到结尾的所有字符

删除函数：

1.s.erase(s.begin()+3); // 删除函数，删除字符串第3个字符后的第一个字符，也就是第四个字符

2.s.erase(s.begin(),s.begin()+3); // 删除函数，删除字符串第1到第3的所有字符，虽然s.begin()+3指向从头起第四个字符，但是最后这个字符是不删除的

3.s.erase(1,3); // 删除函数，删除字符串从1位置（第二个字符）起的3个字符

提取函数：

1.s=ss.substr(1,3); // 提取函数，提取ss字符串从1位置起的3个字符给s字符串

2.s=ss.substr(); // 提取函数，提取ss字符串的所有内容给s字符串

3.s=ss.substr(3); // 提取函数，提取ss字符串从3位置起的所有内容给s字符串

查找函数：

1.a=s.find('A',1); // 提取函数，a是string::size_type类型，从前面1位置开始查找，查找A字符最早出现的位置，若没找到，则返回string::npos

2.a=s.find(ss,1); // 提取函数，从前面1位置开始查找，查找ss字符串最早出现在s字符串的位置，若没找到，则返回string::np

3.a=s.find(cs,1); // 提取函数，从前面1位置开始查找，查找C字符串cs最早出现在s字符串的位置，若没找到，则返回string::npos

4.a=s.find(cs,1,2); // 提取函数，从前面1位置开始查找，查找C字符串cs中前两个字符最早出现在s字符串的位置，若没找到，则返回string::npos；注意string字符串没有该格式函数

5.a=s.rfind('A'); // 提取函数，从后查找，查找A字符最先出现的位置，若没找到，则返回string::npos

6.a=s.find_first_of(ss); // 提取函数，从前查找，ss字符串中任一字符出现在s字符串中的位置

7.a=s.find_first_of(ss,3); // 提取函数，从第3个字符后查找（即第4个字符开始），ss字符串中任一字符最先出现在s字符串中的位置

8.a=s.find_last_of(ss); // 提取函数，从前查找，ss字符串中任一字符最后一次出现在s字符串中的位置；换句话说，从后查找，最先出现的位置

9.a=s.find_last_of(ss,3); // 提取函数，从后面第3个字符后查找（即第4个字符开始），ss字符串中任一字符最先出现在s字符串中的位置；换句话说，在s后面第3个字符位置前的字符串中，ss任一字符最后一次出现在此字符串中的位置

10.a=s.find_first_not_of(ss); // 提取函数，从前查找，任一非ss字符串中字符最早出现在s字符串中的位置

11.a=s.find_first_not_of(ss,3); // 提取函数，从第3个字符后查找（即第4个字符开始），任一非ss字符串中字符最先出现在s字符串中的位置

12.a=s.find_last_not_of(ss); // 提取函数，从前查找，任一非ss字符串中字符最后一次出现在s字符串中的位置；换句话说，从后查找，最先出现的位置

13.a=s.find_last_not_of(ss,3); // 提取函数，从后面第3个字符后查找（即第4个字符开始），任一非ss字符串中字符最先出现在s字符串中的位置；换句话说，在s后面第3个字符位置前的字符串中，任一非ss字符串中字符最后一次出现在此字符串中的位置

比较函数：

1.s.compare(ss); // 比较函数，直接比较s和ss的字符串大小，从第一个字符开始比，若一样则下一个；若s大于ss则返回1，等于返回0，小于返回-1

2.s.compare(2,2,ss); // 比较函数，用s字符串第二个字符后的两个字符作为子字符串，来和ss比较

3.s.compare(2,2,ss,1,3); // 比较函数，用s字符串第二个字符后的两个字符作为子字符串，来和ss第一个字符后三个字符组成的子字符串比较

替换函数：

1.s.replace(1,2,ss); // 替换函数，将s字符串第一个字符后的两个字符替换为ss字符串

2.s.replace(s.begin(),s.begin()+3,ss); // 替换函数，将s字符串从头起的三个字符替换为ss字符串

3.s.replace(1,2,ss,2,3); // 替换函数，将s字符串第一个字符后的两个字符替换为ss字符串第二个字符后的三个字符

4.s.replace(1,2,ss,2); // 替换函数，将s字符串第一个字符后的两个字符被替换，若ss为string字符串，则进行替换的字符串为ss字符串第二个字符后的所有字符；若ss为C字符串，则进行替换的字符串为ss字符串的前两个字符

5.s.replace(s.begin(),s.begin()+3,ss,2); // 替换函数，将s字符串从头起的三个字符替换为C字符串ss的前两个字符，注意ss字符串只能是C字符串而不是string字符串

6.s.replace(0,3,5,‘A’); // 替换函数，将s字符串从头起的三个字符替换为5个A字符

7.s.replace(s.begin(),s.begin()+3,5,‘A’); // 替换函数，将s字符串从头起的三个字符替换为5个A字符

1.5 string.h 文件库

1.puts：输出字符串，输出完成后自动换行，用法puts(a); [a为字符数组]
2.gets：输入一个以回车结束的字符串，用法gets(a); [a为字符数组]
2.1-> 注意：以上两个函数只能接收一个字符串
3.strcat：连接两个字符串，用法：strcat(str1,srt2)；
4.strcpy：将后一个字符数组内容拷贝到前一个字符数组内，用法：strcpy(字符数组1,字符串2)；
5.strcmp：比较两个字符串的内容，比较其ASCⅡ码值，返回值为int型，返回值如下，用法：if(strcmp(str1,str2)==0)  printf(“yes”);
/*
返回值:返回imnt型整数。其值是ASCII码的差值
a.若字符串1< 字符串2，返回负整数
b，若字符串1> 字符串2， 返回正整数
c.若字符串1=- 字符串2，返回零
*/
6.strlen：字符串长度，返回字符串实际长度，不包含‘\0’
7.strlwr：大写字母转换成小写，用法：strlwr(字符串);
8.strupr：小写字母转换成大写，用法：strupr(字符串);
9.strrev：数组逆序，用法：strrev(字符串);

文件处理

2.1 逐个字符复制

char ch;
while((ch=fin.get())!=EOF)
{
    fout.put(ch);
}

2.2 部分复制

char line[1024];
while(fin.peek()!=EOF)
{
    fin.read(line,1024);
    fout.write(line,fin.gcount());
}

2.3 一行复制

char line[1024];
while(fin.peek()!=EOF)
{
    fin.getline(line,1024);
    fout.write(line,fin.gcount());
    fout.put('\n');
}

类

3.1 构造函数：

作用：创建对象时，为数据成员初始化

在对象创建时由系统自动调用

如果程序中未声明，则系统自动产生出一个默认的参数列表为空的构造函数

构造方法的方法名和类名相同，构造方法*不需要返回值类型

名字与类名相同

构造函数可以重载

创建对象时系统自动调用

3.2 析构函数

完成对象被删除前的一些清理工作

在对象的生存期结束的时刻，系统自动调用它，然后再释放此对象所属的空间

如果程序中未声明析构函数，编译器将自动产生一个隐含的析构函数

析构函数的名字在类名前加“~ ”字符

一个类中只能定义一个析构函数

函数体结束时或使用delete运算符释放new运算符创建的对象时被自动调用

3.3 拷贝初始化构造函数

每个类都必须一个，没有则由编译系统生成一个“缺省拷贝初始化构造函数”

当用类的一个对象去初始化该类的另一个对象时系统自动调用拷贝构造函数实现拷贝赋值

3.4 this指针

this指针存放的是类的首地址

this指针不占用类的内存

静态函数不存在this指针，静态函数先于类存在

3.5 静态数据成员

是类的所有对象共享的成员，而不是某个对象的

对多个对象来说，静态数据成员只储存在一个地方，供所有对象使用

静态数据成员的值对每个对象都是一样的，但其值可以被任何一个对象更新

静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化

静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员

静态成员函数中要引用非静态成员时，可以通过对象来引用

3.6 友元

是一种定义在类外部的类或普通函数，但需要在类体内进行说明(前面加friend关键字）

不是成员函数，但可以访问类中的私有成员

常见问题

4.1 运算符优先级

​ “ != ” > “ = “

for(c=getchar()!=EOF) //先进行不等于比较
for((c=getchar())!=EOF) //先进行赋值运算

4.2 !a含义

当a值为0时，!a的值是1,否则是0。

4.3 宏定义不加分号

#define A 1  //定义常量A的值为1
#define AB printf("Hello Word.");  //宏定义也可这样定义，注意定义语句时，最后要加分号，这个分号是语句的，而不是宏定义的
#undef A   //停止常量A的作用域（下图例）

4.4 C语言中除了“0”，其他值都为真

4.5 问号表达式：

(表达式1)?(表达式2):(表达式3);
//若表达式1为真，则执行表达式2，否则执行表达式3

4.6 scanf 格式化输入

scanf("%de%d",&a,&b); //无法获取b的数值，分割符为空格、逗号

4.7 nptr字符串 是一个以有数字或‘-’的字符开头‘+’数字的字符串