day(0天)----2月4日
1：C++基础语言学习---->看c++的pdf记录学习；
1.1: 二维数组练习题
代码：
代码效果图：
2.1： 总结：64位系统的存放指针的所用指针变量大小内存是8个字节（64/8=8）
32位系统的存放指针的所用指针变量大小内存是4个字节（32/8=4）
day(1天)----2月5日
1: 结构体定义和使用
2: 结构体数组 struct 结构体名 数组名[元素个数] = { {} , {} , ... {} }
3: 结构体指针
4: 结构体嵌套结构体
5: 结构体做函数参数
6: 结构体中 const使用场景
结构体练习题：
代码：
#include <iostream>
using namespace std;
//同学结构体创建
struct Student{
string name;
int score;
};
//老师结构体创建
struct Teacher{
string teacher_name;
struct Student student[5]; //同学结构体
};
int main(){
struct Teacher teacher[3];
teacher[0].teacher_name="张飞老师"; //老师名字定义
teacher[0].student[0].name="张飞一同学";
teacher[0].student[0].score=100;
teacher[0].student[1].name="张飞二同学";
teacher[0].student[1].score=95;
teacher[0].student[2].name="张飞三同学";
teacher[0].student[2].score=90;
teacher[0].student[3].name="张飞四同学";
teacher[0].student[3].score=85;
teacher[0].student[4].name="张飞五同学";
teacher[0].student[4].score=80;
//打印输出
for(int i=0;i<5;i++)
cout<<teacher[0].student[i].name<<"::"<< teacher[0].student[i].score<<endl;
return 0;
}运行效果图：
练习题2：
代码：
#include <iostream>
using namespace std;
struct Hero{
string name; //姓名
int age; //年龄
string sex; //性别
};
int main()
{
//定义5个英雄基本信息
struct Hero hero[5]={
{"刘备",23,"男"}, //hero[0]
{"关羽",22,"男"}, //hero[1]
{"张飞",20,"男"}, //hero[2]
{"赵云",21,"男"}, //hero[3]
{"貂蝉",19,"女"} //hero[4]
};
// 冒泡排序
// 23 22 20 21 19
//第一轮循环结束--->找出最大出来
// 22 23 20 21 19 i=0;
// 22 20 23 21 19 i=1;
// 22 20 21 23 19 i=2;
// 22 20 21 19 23 i=3;
// 0-4 5轮
// 0-3 4轮
// 0-2 3轮
// 0-1 2轮
for(int i=0;i<4;i++) //外面跑四次,依次寻找四个最大出来
{
for(int j=0;j<4-i;j++)
{
if(hero[j+1].age<hero[j].age)
{
int temp=hero[j+1].age; //保留前者的年龄大小;
hero[j+1].age=hero[j].age;
hero[j].age=temp;
}
}
}
for(int i=0;i<5;i++) //打印输出
cout<<" "<<hero[i].age<<endl;
return 0;
} 运行效果图：
C++核心编程:
利用new在堆区开辟新的空间：
#include <iostream>
using namespace std;
int* fun()
{
int* a=new int(10); //在堆区开辟整型数字为10的数据空间
return a;
}
int main()
{
int* p=fun();
cout<<*p<<endl;
delete p; //释放堆区空间
//cout<<*p<<endl; //不可以访问，释放堆区空间之后,否则会出错
return 0;
} 代码效果图：
day(2天)----2月7日(之前跑去吃酒席了，。。。放了两天今天弥补一下)
1.1 ：初始化列表，初始化类里面的对象；
C++提供了初始化列表语法，用来初始化属性
语法： 构造函数()：属性1(值1),属性2（值2）... {} 注意：构造函数需要与类的名字是一样。
例子代码：
#include <iostream>
using namespace std;
class Person{
//行为
public:
Person(string a, int b, string c):m_name(a), m_age(b), m_sex(c) {} //列表初始化代码
void Printf_Person(void){
cout<< "名字: "<<m_name<<endl;
cout <<"年龄："<<m_age <<endl;
cout<< "性别："<<m_sex <<endl;
}
//属性
public:
string m_name;
int m_age;
string m_sex;
};
int main()
{
Person people("张飞",20,"男");
people.Printf_Person(); //打印对象
return 0;
} 代码效果：
1.2：若采用传统赋值方式也是可以的，下面给出代码，利用内置函数可以操作。
传统代码赋值方式：
//传统赋值方式
void Set_Person(string a, int b, string c){
m_name=a;
m_age=b;
m_sex=c;
}#include <iostream>
using namespace std;
class Person{
//行为
public:
Person(string a, int b, string c):m_name(a), m_age(b), m_sex(c) {} //列表初始化代码
void Printf_Person(void){
cout<< "名字: "<<m_name<<endl;
cout <<"年龄："<<m_age <<endl;
cout<< "性别："<<m_sex <<endl;
}
//传统赋值方式
void Set_Person(string a, int b, string c){
m_name=a;
m_age=b;
m_sex=c;
}
//属性
public:
string m_name;
int m_age;
string m_sex;
};
int main()
{
Person people("张飞",20,"男");
people.Set_Person("关羽",25,"男"); //传统赋值方式
people.Printf_Person(); //打印对象
return 0;
} 代码效果图：
1.3 构造函数与析构函数的顺序问题；
1.3.1：先是构造小的里面类的对象，再构造本类的构造。
1.3.2：析构的顺序先是析构大的，再析构小的部分的类。
代码：
#include <iostream>
using namespace std;
//
定义手机类
class Phone{
public:
//构造函数
Phone(string phone_name){
m_PhoneName=phone_name;
cout<< "这是 Phone 的构造函数 " << endl;
}
//析构函数
~Phone(){
cout << "这是Phone的析构函数 " << endl;
}
string m_PhoneName;
};
//定义人类
class Person{
//行为
public:
//构造函数,同时加上初始化步骤存在;
Person(string a , string b): m_people_name(a),phone_1(b) {
cout<< "这是 Person 的构造函数 " << endl;
}
//析构函数
~Person(){
cout << "这是Person的析构函数 " << endl;
}
void play_game(void){
cout<< m_people_name << "使用" << phone_1.m_PhoneName << "牌手机" << endl;
}
//属性
public:
string m_people_name;
Phone phone_1; //类具体的一个实例;
};
int main()
{
Person people_1("张飞","华为");
people_1.play_game();
return 0;
}
代码效果图：
day(3天)----2月8日
静态成员变量特点
1:所用对象共享同一份数据
2：编译阶段分配内存
3: 类内声明，类外初始化。
静态成员函数特点:
1：静态成员函数只能使用静态成员变量(static 变量)
2：静态成员函数调用有两种方式：
2.1 使用对象调用
2.2 使用 类名：：函数名 的方式调用
指针常量与常量指针区别？
指针常量和常量指针的区别主要在于它们对指针本身和指针所指向的内容的限制不同。
指针常量（pointer to constant）指的是一个指针，它指向的地址是常量，即指针本身是不可变的，但是可以通过指针改变所指向的内容。这意味着指针无法指向其他地址，但可以通过指针修改所指向地址的内容。
常量指针（constant pointer）指的是一个指针，它指向的内容是常量，即指针本身是可变的，但无法通过指针修改所指向的内容。这意味着指针可以指向其他地址，但无法通过指针修改所指向地址的内容。
疑惑解答：
1: (指针常量----pointer to constant )什么叫做指向的地址是常量？
当说到指向的地址是常量时，指的是指针本身指向的地址是不可变。这意味着一旦指针指向了某个地址，就不能再指向其他地址。因为这个地址是不能改变，就是固定了，所以就称之为常量。
举例代码:
#include <iostream>
using namespace std;
int main()
{
int a=10,b=20;
int* const p=&a; //指向a,不能指向其他地方了
*p=200; //pointer to constant ,可以改变指向地址内容值
cout<<"*p="<<*p<<endl;
return 0;
}代码效果图：
2:(常量指针------constant pointer) 什么叫做指向的内容是常量？
当说到指向的内容是常量时，指的是指针所指向的地址上的值是不可变。这意味着无法通过指针来修改所指向地址上的值。
代码:
#include <iostream>
//常量指针
using namespace std;
int main()
{ // constant pointer
const int* p; //常量指针--->指针指向的内容是常量, 不可以改变
int a=10,b=20;
p=&a; //指向a;
cout<<"*p="<<*p<<endl;
p=&b; //指向b;
cout<<"*p="<<*p<<endl;
//*p=300; //不可以是
return 0;
} 代码效果图：
4: 友元功能？
在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术
友元的三种实现？
4.1：全局函数做友元
4.2: 类做友元
4.3: 成员函数做友元
4.1 全局函数做友元
#include <iostream>
using namespace std;
class Building{
//友元函数声明
friend void goodGay(Building* building); //好基友函数
public://构造函数公有声明
Building(void){
m_SittingRoom="客厅";
m_BedRoom="卧室";
}
public:
string m_SittingRoom;
private:
string m_BedRoom;
};
//这是全局函数，而并不是成员函数
void goodGay(Building* building){
cout << "好基友正在访问： " << building->m_SittingRoom << endl;
cout << "好基友正在访问： " << building->m_BedRoom << endl;
}
int main(void){
Building b;
goodGay(&b);
return 0;
} 代码效果图：
4.2 类做友元
day(4天)----2月9日
1：今天写代码，又忘记了，引用的用法，现在重新补一下引用的用法。
引用常见用法：
2：面向对象第二特性------>继承
下级别的成员除了拥有上一级的共性，还有自己的特性。
继承好处：
1：减少代码重复性
2: class A: 继承方式 B;(A 称为子类或者派生类,B称为父类或者基类,继承方 式:public,private,protect)
3: 继承方式
派生类中的成员，包含两大部分：
第一类：从基类继承过来属性成员。
第二类: 派生类自己增加的成员，新增的属性成员体现了其个性。
private修饰的东西只能在本类中访问。
举例子：
例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同。接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处
普通实现方法；
代码：
运行效果图：
继承实现方法：
代码：
运行效果图：
继承方式：
继承同名成员处理方式：
继承中同名静态成员处理方式：
代码：
运行效果图：
多继承语法功能：
多态案例
多态举例代码：
#include <iostream>
#include <string>
using namespace std;
//主机
class Cpu{
//记得把基类的虚函数设置为公有属性;
public:
virtual void Calculate()=0;
};
//显卡
class Show_Card{
public:
virtual void Show_Picture()=0;
};
//内存
class Storage{
public:
virtual void Storage_Data()=0;
};
//英特尔电脑厂商
class Inter_Cpu: public Cpu{
public:
virtual void Calculate(){
cout<<"这是英特尔的CPU"<<endl;
}
};
class Inter_Show_Card: public Show_Card{
public:
virtual void Show_Picture(){
cout<<"这是英特尔的显卡"<<endl;
}
};
class Inter_Storage: public Storage{
public:
virtual void Storage_Data(){
cout<<"这是英特尔的内存"<<endl;
}
};
//联想电脑厂商
class Lenovo_Cpu: public Cpu{
public:
virtual void Calculate(){
cout<<"这是联想的CPU"<<endl;
}
};
class Lenovo_Show_Card: public Show_Card{
public:
virtual void Show_Picture(){
cout<<"这是联想的显卡"<<endl;
}
};
class Lenovo_Storage: public Storage{
public:
virtual void Storage_Data(){
cout<<"这是联想的内存"<<endl;
}
};
//计算机卡槽类
class Computer{
public:
Computer(Cpu* cpu ,Show_Card* show_card ,Storage* storage){ //工具人变量
m_cpu=cpu;
m_show_card=show_card;
m_storage=storage;
}
//执行零件功能
void Do_Work(void){
m_cpu->Calculate();
m_show_card->Show_Picture();
m_storage->Storage_Data();
}
//析构函数
~Computer(){
if(m_cpu!=NULL){
delete m_cpu; //释放对象所占用的内存和资源
m_cpu=NULL;
}
if(m_show_card!=NULL){
delete m_show_card;
m_show_card=NULL;
}
if(m_storage!=NULL){
delete m_storage;
m_storage=NULL;
}
}
public:
Cpu* m_cpu;
Show_Card* m_show_card;
Storage* m_storage;
};
int main()
{
//多态模式方式---->第一台
cout<<"-----------第一台计算机--------"<<endl;
Computer* C1 =new Computer(new Inter_Cpu,new Inter_Show_Card,new Lenovo_Storage);
C1->Do_Work(); //调用成员函数
delete C1;
cout<<"------------第二台计算机----------"<<endl;
//计算机第二台
Inter_Cpu* inter_cpu=new Inter_Cpu;
Inter_Show_Card* inter_show_card=new Inter_Show_Card;
Inter_Storage* inter_storage=new Inter_Storage;
Computer* C2=new Computer(inter_cpu,inter_show_card,inter_storage);
C2->Do_Work();
delete C2;
return 0;
}运行效果图：
day(7天)----2月12日
1：函数模板学习
ISO C++ 标准禁止将字符串常量直接转换为 char* 类型的指针，以防止不安全的操作，因为字符串常量通常是只读的。
函数模板通用知识点：
函数模板举例代码:
#include <iostream>
using namespace std;
int template_mode=1; //函数模板模式选择
/*知识点会议
template_mode=1:使用函数模板,必须确定数据类型与函数模板能够匹配
template_mode=2:函数模板可以指定显示转换功能; Swap<int>(num3,num4);
template_mode=3:函数模板声明两种通用类型数据;
template_mode=4:函数模板提供函数重载功能;
*/
template <typename T>
void Swap(T& a , T& b){
T temp=a;
a=b;
b=temp;
}
//两种通用的函数模板类型
template <typename T1 , typename T2 >
void Show_Love(T1 number , T2 m_message) {
cout<<"亲爱的"<<number<<"号："<< m_message << endl;
}
//提供函数重载功能
template <typename T1>
void func(T1 a){
cout<<" func--1 "<<endl;
}
template <typename T1, typename T2> //一个函数模板只能提供一个函数，下面不能有两个
void fun(T1 a, T2 b){
cout<<" func--2 "<<endl;
}
template <typename T1, typename T2>
void fun(T1 a, T2 b , int c){
cout<<" func--3 "<<endl;
}
int main(void){
template_mode=4;
if(template_mode==1){
int num1=2,num2=22;
Swap(num1,num2);
cout<<num1<<"--"<<num2<<endl;
}
else if(template_mode==2){
int num3=21;
char num4=10;
// Swap<int>(num3,num4);
// cout<<num3<<"--"<<num4<<endl;
}
else if(template_mode==3){
int num5=4;
string mes1="我喜欢你";
const char* mes2="我不喜欢你"; /*ISO C++ 标准禁止将字符串常量直接转换为 char* 类型的指针，以防止不安全的操作，因为字符串常量通常是只读的*/
Show_Love(num5,mes2);
}
else if(template_mode==4){
int num5=1,num6=2,num7=3;
func(num5);
func(num5,num6);
func(num5,num6,num7);
}
return 0;
} 2:函数模板具体化知识点：
template <> void 函数模板名 <参数列表>
代码：
#include <iostream>
using namespace std;
class beautiful_girl{
public:
string m_name; //姓名
int m_age; //年龄
int m_rank; //排名
};
//函数模板
template <typename T>
void Swap(T& a , T& b){
T temp=a;
a=b;
b=temp;
}
//函数模板具体化,里面函数定义都是具体的对象
template<>
void Swap(beautiful_girl& a,beautiful_girl& b){
cout<<"调用函数具体化"<<endl;
int temp= a.m_rank;
a.m_rank=b.m_rank;
b.m_rank=temp;
}
int main(void){
beautiful_girl g1,g2;
g1.m_rank=10;
g2.m_rank=20;
Swap(g1,g2);
cout<<"g1="<<g1.m_rank<<"---"<<"g2="<<g2.m_rank<<endl;
return 0;
}运行代码效果图：
先声明函数模板，再定义函数。
代码：
#include <iostream>
using namespace std;
class beautiful_girl{
public:
string m_name; //姓名
int m_age; //年龄
int m_rank; //排名
};
//函数模板
template <typename T>
void Swap(T& a , T& b);
//函数模板具体化,里面函数定义都是具体的对象
template<> void Swap(beautiful_girl& a,beautiful_girl& b);
int main(void){
beautiful_girl g1,g2;
g1.m_rank=10;
g2.m_rank=20;
Swap(g1,g2);
cout<<"g1="<<g1.m_rank<<"---"<<"g2="<<g2.m_rank<<endl;
return 0;
}
template <typename T>
void Swap(T& a , T& b){
T temp=a;
a=b;
b=temp;
}
template<> void Swap(beautiful_girl& a,beautiful_girl& b){
cout<<"调用函数具体化"<<endl;
int temp= a.m_rank;
a.m_rank=b.m_rank;
b.m_rank=temp;
}运行效果图：
3：普通函数，函数模板，具体化函数模板调用顺序问题
代码举例：
#include <iostream>
using namespace std;
void Swap(int a , int b){
cout<<"这是调用普通函数"<<endl;
}
template <typename T>
void Swap(T a , T b){
cout<<"这是调用函数模板"<<endl;
}
//函数模板具体化
template <>
void Swap(int a, int b){
cout<<"这是调用具体化函数模板"<<endl;
}
int main(void){
Swap(1,1);
Swap<>(1,1); //调用函数模板
return 0;
} 运行结果：
总结：普通函数>>函数模板>>具体化函数模板
day(8天)----2月13日
1: 在.h与.c文件调用函数程序问题。
下面分为三种类型的函数，普通函数，函数模板，具体化函数模板
2:dectype 与 auto 区别以及使用
3:类模板
3.1 类模板语法
类模板代码
template <class T1 , class T2 >
class Person{
//行为
public:
//构造函数
Person(T1 name ,T2 age){
this->m_name=name;
this->m_age=age;
}
void Show_Message(void){
cout<< m_name << "的年龄是" << m_age << "岁"<<endl;
}
//属性
public:
T1 m_name;
T2 m_age;
};代码：
#include <iostream>
using namespace std;
template <class T1 , class T2 >
class Person{
//行为
public:
//构造函数
Person(T1 name ,T2 age){
this->m_name=name;
this->m_age=age;
}
void Show_Message(void){
cout<< m_name << "的年龄是" << m_age << "岁"<<endl;
}
//属性
public:
T1 m_name;
T2 m_age;
};
int main(void){
Person<string,int> Person1("孙悟空",100);
Person1.Show_Message();
return 0;
} 运行效果：
day(9天)----2月14日
1：STL定义 -----> stand template library
STL核心基本组成：容器，算法，迭代器，仿函数，适配器，空间配置器
2：容器(vector)
2.1： 知识点：查询容器数据
第一种方法: 通过迭代器查询容器里面数据内容数据；
代码：
#include <iostream>
#include <vector> //向量
using namespace std;
int main(void){
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
//iterator是一个计算机科学术语，指的是一种用于遍历集合或序列的对象
vector<int>::iterator itBegin=v.begin();
vector<int>::iterator itEnd=v.end();
while(itBegin!=itEnd){
cout<< *(itBegin++) <<endl;
}
return 0;
} 运行效果图：
第二种方法：使用for循环通过迭代器访问容器数据内容
代码：
#include <iostream>
#include <vector> //向量
using namespace std;
int main(void){
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
//iterator是一个计算机科学术语，指的是一种用于遍历集合或序列的对象
vector<int>::iterator itBegin=v.begin();
vector<int>::iterator itEnd=v.end();
while(itBegin!=itEnd){
cout<< *(itBegin++) <<endl;
}
cout<<"第二种模式"<<endl;
//使用for循环遍历方式;
for(vector<int>::iterator itBegin=v.begin() ; itBegin!=v.end() ; itBegin++ ){
cout<< *(itBegin) <<endl;
}
return 0;
}
运行效果图：
第三种方法：使用for_each访问数据
代码:
#include <iostream>
#include <vector> //向量
#include <algorithm>
using namespace std;
void myPrint(int val){
cout<< val <<endl;
}
int main(void){
vector<int> v;
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
//iterator是一个计算机科学术语，指的是一种用于遍历集合或序列的对象
vector<int>::iterator itBegin=v.begin();
vector<int>::iterator itEnd=v.end();
while(itBegin!=itEnd){
cout<< *(itBegin++) <<endl;
}
cout<<"第二种模式，使用for循环遍历方式"<<endl;
//使用for循环遍历方式;
for(vector<int>::iterator itBegin=v.begin() ; itBegin!=v.end() ; itBegin++ ){
cout<< *(itBegin) <<endl;
}
cout<<"第三种模式，使用STL标准库函数"<<endl;
for_each(v.begin(),v.end(),myPrint);
return 0;
} 代码运行效果图：
2.2： 知识点：类的对象作为容器内容
代码：
#include <iostream>
#include <vector>
using namespace std;
class Person{
//行为:
public:
Person(string name , int age){
this->m_age=age;
this->m_name=name;
}
//属性
public:
int m_age;
string m_name;
};
int main(void){
vector<Person> v;
Person p1("卢本伟",66);
Person p2("听泉寻宝",16);
Person p3("张飞",6);
Person p4("迪迦",116);
Person p5("戴拿",6116);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
for(vector<Person>::iterator itBegin=v.begin(); itBegin!=v.end(); itBegin++){
cout << (*itBegin).m_name<<"::" << (*itBegin).m_age << endl;
}
return 0;
}运行效果：
总结：在类的对象作为容器内容时候，需要考虑对象具体属性，否则会报错。
使用类的指针作为内容时候：
代码：
#include <iostream>
#include <vector>
using namespace std;
class Person{
//行为:
public:
Person(string name , int age){
this->m_age=age;
this->m_name=name;
}
//属性
public:
int m_age;
string m_name;
};
void test01(void){
vector<Person> v;
Person p1("卢本伟",66);
Person p2("听泉寻宝",16);
Person p3("张飞",6);
Person p4("迪迦",116);
Person p5("戴拿",6116);
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
for(vector<Person>::iterator itBegin=v.begin(); itBegin!=v.end(); itBegin++){
cout << (*itBegin).m_name<<"::" << (*itBegin).m_age << endl;
}
}
//容器内部存放对象指针变量;
void test02(void){
vector<Person*> v;
Person p1("卢本伟",66);
Person p2("听泉寻宝",16);
Person p3("张飞",6);
Person p4("迪迦",116);
Person p5("戴拿",6116);
v.push_back(&p1);
v.push_back(&p2);
v.push_back(&p3);
v.push_back(&p4);
v.push_back(&p5);
cout<<"第一种查询元素方式：使用->方式" <<endl;
for(vector<Person*>::iterator itBegin=v.begin(); itBegin!=v.end(); itBegin++){
cout << (*itBegin)->m_name <<"::" << (*itBegin)->m_age << endl;
}
cout<<"第二种元素查询方式."<<endl;
for(vector<Person*>::iterator itBegin=v.begin(); itBegin!=v.end(); itBegin++){
cout << (*(*itBegin)).m_name<<"::" << (*(*itBegin)).m_age << endl;
}
}
int main(void){
//test01();
test02();
return 0;
}运行效果：
总结：-> 等价 *(地址) 的使用用法
二维容器变量：
day(10天)----2月15日
string 容器
1.1 string赋值操作
代码：
#include <iostream>
#include <string>
using namespace std;
int main(void){
string s1="你好";
s1+="听泉寻宝";
cout<<s1<<endl;
string s2;
s2.assign("听泉");
cout<<s2<<endl;
return 0;
} 运行效果图
1.2 string字符串拼接
#include <iostream>
using namespace std;
int main(void){
string s1="你好";
s1+="听泉寻宝";
cout<<s1<<endl;
return 0;
} 运行效果图：
1.3 string字符串查找与替换
代码：
#include<iostream>
#include<string>
using namespace std;
void MyPrint_String(string s){
cout<< s <<endl;
}
void MyPrint_Val(int val){
cout<< val <<endl;
}
int main(void){
// 01234567
string s1="abcdefde";
int pos=s1.find("de");
MyPrint_Val(pos);
//rfind--->从右往左开始查找功能
pos=s1.rfind("de");
MyPrint_Val(pos);
//替换功能使用函数 replace函数
s1.replace(1,3,"111111"); //将s1中的bcd替换成 111111 字符串功能
MyPrint_String(s1);
return 0;
} 运行效果图：
1.4 string字符串比较
代码:
#include<iostream>
#include<string>
using namespace std;
void MyPrint_String(string s){
cout<< s <<endl;
}
void MyPrint_Val(int val){
cout<< val <<endl;
}
int main(void){
string s1="hello";
//s1 > "aello" 返回结果是1
int result = s1.compare("aello");
MyPrint_Val(result);
//s1 = "aello" 返回结果是0
result = s1.compare("hello");
MyPrint_Val(result);
//s1 < "wello" 返回结果是-1
result = s1.compare("wello");
MyPrint_Val(result);
return 0;
} 运行效果图：
1.5 string 插入与删除
代码:
#include<iostream>
#include<string>
using namespace std;
void MyPrint_String(string s){
cout<< s <<endl;
}
void MyPrint_Val(int val){
cout<< val <<endl;
}
int main(void){
//0123
string s1="love";
s1.insert(0,"l");//添加功能
MyPrint_String(s1);
s1.erase(0,1); //删除功能
MyPrint_String(s1);
s1.erase(0,1);//删除功能
MyPrint_String(s1);
return 0;
} 运行效果图:
1.6 string子串
1.7 string字符串存取
代码：
#include<iostream>
#include<string>
using namespace std;
void MyPrint_String(string s){
cout<< s <<endl;
}
void MyPrint_Val(int val){
cout<< val <<endl;
}
int main(void){
string s1="hello";
MyPrint_String("使用索引[]进行访问 ");
for(int i=0;i<s1.size();i++){
cout<< s1[i] <<" ";
}
MyPrint_String(" ");
MyPrint_String("使用at(i)进行访问");
//使用at(i)进行访问;
for(int i=0;i<s1.size();i++){
cout<< s1.at(i) <<" ";
}
//使用两者方式修改
s1[0]='x'; //这里是单独添加单个字符,注意是修改的字符在里面进行操作.
s1.at(1)='a';
MyPrint_String(s1);
return 0;
} 运行效果图
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
