方法1：
char ValueArrays[1024]{};

while (ifs >> ValueArrays)//非零即为真
{
cout << ValueArrays << endl;//这是字符串的打印
}

方法2：

string str = " ";
while (ifs >> str)
{
cout << str << endl;
}

（4）关闭流

ifs.close();

（5）存储案例展示：（存储数据到UserInfo的txt文本中，读取数据，新增数据，查找相关姓名、年龄、地址）


#include <iostream>
#include<fstream>  
#include<string>
#include"User.h"
/*
预处理
#include中的" "和<>的使用
<>:代表的导入C++库文件
“ ”：先检索是否有没有自己写的头文件，如果检索不到自己写的头文件，会自动查找C++库，找不到就报错
*/
 
 
using namespace std;
void Save()
{
    using namespace std;
    ofstream ofs;
    ofs.open("abc.txt", ios::out);
    string name;
    getline(cin, name,'q');
    ofs << name << endl;
    
    
    ofs.close();
  
}
int name_index = 0;
void Add(string nameArrays[])//name是一个形参，需要一个string 类型数组的地址
{
    string name = " ";
    cin >> name;
    nameArrays[name_index] = name;
    name_index++;
    ofstream ofs;
    ofs.open("abc.txt", ios::out);
    for (int i = 0; i < name_index; i++)
    {
        ofs << nameArrays[i] << endl;
    }
    ofs.close();
}
 
void GetValue()
{
    using namespace std;
    //1. 创建对象
    ifstream ifs;
    //2. 开流
    ifs.open("abc.txt", ios::in);
    //3.读取数据，方法1
        //3.1数据本地读取出来了，需要找到一个容器去存放读取出来的数据
    char ValueArrays[1024]{};
        //3.2开始取出数据，并将本地数据在数据中
    while (ifs >> ValueArrays)//非零即为真
    {
        cout << ValueArrays << endl;//这是字符串的打印
    }
    ifs.close();
    cout << "---------" << endl;
    //3.读取数据，方法2
        //3.1数据本地读取出来了，需要找到一个容器去存放读取出来的数据
        //读取不走回头路
    ifs.open("abc.txt", ios::in);
    string str = " ";
    while (ifs >> str)
    {
        cout << str << endl;
    }
    ifs.close();
    cout << "--------" << endl;
    //3.读取数据，方法3 借助一个ifstream里的一个函数getline
    ifs.open("abc.txt", ios::in);
    char buf[1024]{};
    while (ifs.getline(buf, sizeof(buf)))//getline是ifstream下的一个函数，用于获取到一行数据，函数的第一个参数是用于接收一行数据的字符数组，
        //第二个参数是用于接收数据的容器的大小
 
    {
        cout << buf << endl;
    }
    ifs.close();
    cout << "--------" << endl;
 
    //3.读取数据，方法4 借助一个string里的一个函数getline
    ifs.open("abc.txt", ios::in);
    string str_buf = {};
    while (getline(ifs, str_buf))
    {
        cout << str_buf << endl;
    }
    ifs.close();
 
    cout << "--------" << endl;
 
    //3.读取数据，方法5 借助一个ifstream里的一个函数eof
    ifs.open("abc.txt", ios::in);
    char eof_buf[1024]{};
    while (!ifs.eof())
    {
        ifs >> eof_buf;
        cout << eof_buf << endl;
    }
    ifs.close();
}
 
void SetValue()
{
    string name = " ";
    string age = " ";
    string address = " ";
    cout << "请输入姓名：" << endl;
    cin >> name;
    cout << "请输入年龄：" << endl;
    cin >> age;
    cout << "请输入地址：" << endl;
    cin >> address;
    ofstream ofs;
    ofs.open("Value.txt", ios::out);
    ofs << name << "  ";
    ofs << age << "  ";
    ofs << address << endl;
    ofs.close();
}
 
void SelValue()
{
    string r_name = " ";
    string r_age = " ";
    string r_address = " ";
    ifstream ifs;
    ifs.open("Value.txt", ios::in);
    while (ifs >> r_name && ifs >> r_age && ifs >> r_address)
    {
        cout << "姓名：" << r_name << ",年龄：" << r_age << ",地址：" << r_address << endl;
    }
    ifs.close();
}
 
//增加用户
User uArray[6] = {};
int uSize = 0;
void AddUser()
{
    string name;
    int age;
    string address;
    cout << "输入姓名：" << endl;
    cin >> name;
    cout << "输入年龄:" << endl;
    cin >> age;
    cout << "输入地址：" << endl;
    cin >> address;
 
    User uInstance;
    uInstance.name = name;
    uInstance.age = age;
    uInstance.address = address;
 
    uArray[uSize] = uInstance;
    uSize++;
    ofstream ofs;
    ofs.open("UserInfo.txt", ios::out);
    for (int i = 0; i < uSize; i++)
    {
        ofs << uArray[i].name << " ";
        ofs << uArray[i].age << " ";
        ofs << uArray[i].address << endl;
    }
    ofs.close();
}
 
int Find(string name)
{
    for (int i = 0; i < uSize; i++)
    {
        if (uArray[i].name == name)
        {
            return i;
        }
    }
    return -1;
}
 
 
//查询所有人的所有信息
void SelAllUser()
{
    ifstream ifs;
    ifs.open("UserInfo.txt", ios::in);
   //is_open判断上一行代码中打开的文件是否存在
    //存在返回真，不存在返回假
    /*if (ifs.is_open())
    {
        cout << "文件存在" << endl;
    }
    else
        cout << "文件不存在" << endl;*/
    if (!ifs.is_open())
    {
        cout << "文件不存在" << endl;
        return;//文件不存在，下方逻辑不用执行
    }
    char buf[1024];
    ifs >> buf;
    if (ifs.eof())
    {
        cout << "文件存在，但没数据" << endl;
        return;//下方逻辑无需进行
    }
    ifs.close();
    ifs.open("UserInfo.txt", ios::in);
    int i = 1;
    string name;
    int age;
    string address;
    while (ifs >> name && ifs >> age && ifs >> address)
    {
        cout << "第" << i << "人的姓名是" << name << "，年龄是" << age << "，地址是" << address << endl;
    }
   
}
//查询某个人的所有信息
void SelUser()
{
    cout << "输入名字" << endl;
    string sel_name = " ";
    cin >> sel_name;
    int index = Find(sel_name);//Find()会返回一个int类型的值
    if (index != -1) {}//
    ifstream ifs;
    ifs.open("UserInfo.txt", ios::in);
    string name = " ";
    int age = 0;
    string address = " ";
 
    while (ifs >> name && ifs >> age && ifs >> address)
    {
        if (name == sel_name)
        {
            cout << "用户名为：" << name << ",年龄是：" << age << "，地址是：" << address << endl;
        }
    }
}
//初始化
int Init()
{
    ifstream ifs;
    ifs.open("UserInfo.txt", ios::in);
    if (!ifs.is_open())
    {
        cout << "文件不存在" << endl;
        return -1;//文件不存在，下方逻辑不用执行
    }
    char buf[1024];
    ifs >> buf;
    if (ifs.eof())
    {
        cout << "文件存在，但没数据" << endl;
        return -1;//下方逻辑无需进行
    }
    ifs.close();
    ifs.open("UserInfo.txt", ios::in);
    int i = 0;
    string name;
    int age;
    string address;
    while (ifs >> name && ifs >> age && ifs >> address)
    {
        uArray[i].name = name;
        uArray[i].age = age;
        uArray[i].address = address;
        i++;
    }
    return i;
}
int main()
{   
    //string str = {};
    //getline(cin, str, 'q');//控制台输入数据，赋值到str中，按q键再按回车键结束
    //getline(cin, str, '\t');//控制台输入数据，赋值到str中，按Tab键然后再按回车结束
    //cout << str << endl;
    //Save();
    //GetValue();
    //SetValue();
   // SelValue();
    int addIndex = Init();
 
    while (true) {
        cout << "添加：1，查询：2，退出：0" << endl;
        int selecter;
        cin >> selecter;
        switch (selecter)
        {
        case 0:
            exit;
            break;
        case 1:
            AddUser();
            break;
        case 2:
            SelAllUser();
            break;
        }
    }
    system("pause");
}

二、函数

（一）函数的声明和定义

1.函数声明的作用

代表的是函数的出生位置（占位置的），如果在文件最上方的位置声明了函数，不用担心函数和函数之间互相调用编译不通过的问题

2.函数的定义

为函数声明写函数体（写逻辑）

注：可能出现的bug，函数只有声明，没有定义，这个函数却被调用了，被编译时期的异常error

（二）函数传值

1.传出数据（即返回值）

（1）作用：在函数内传数据出函数

（2）样式：

返回类型函数名称（参数）

{

return 对应返回类型的值;

//此处的return有双重作用：

1.跳转语句（跳出函数）

2.返回值

}

（3）可以返回的值：

1.对应返回类型的值

2.对应返回类型的变量

3.带同种返回类型返回值的函数调用——先执行函数调用，再返回值

2.传入数据（即传参）

（1）什么是传参？

传参就是实参传入形参

（2）作用

在函数外部传入数据到函数内部

（3）类型

形参：在函数声明和定义的时候写的是行参

实参：在函数调用的时候传递的值是实参

实参的种类：

对应形参类型的值

对应形参类型的变量

带同种返回类型返回值的函数调用，即先执行函数调用，再传参数（实参传参数）

3.关于形参在函数声明和函数定义中注意点

声明的形参参数名称和定义的形参参数名称
可以不一样声明的时候可以省略参数名称
如果存在函数的默参，默认是必须写在函数声明位置的，不可以在声明和定义中都写一遍默参

4.默参

作用：函数可以在声明或者定义的时候给出默认的逻辑执行

关于默参的放置位置说明
- 如果只有一个默参
  - 放在参数结尾处（最右侧）
- 如果有多个默参
  - 从右到左依次给出默参，中间不可以隔开使用
    - 错误演示：void Function(int i=10,int a,bool b=false)
    - 正确演示:：void Function(int i=10,int a=10,bool b=false)

5.函数重载

函数名相同，但是函数参数（参数类型）不同，通过传入不同的实参，调用不同的函数，执行不同的功能
注意：
- 函数返回值不参与函数重载的过程
- 如果被重载的函数中出现了默参
  - 建议不要写成重载函数
  - 如果不接受建议，就需要保证默参的几个参数类型与其他被重载的函数的参数不一致

6.传参方式

（1）值传递：值传递只能影响本函数，值的修改不会影响其他的功能，也不会影响到实参

（2）地址传递

（3）引用传递

三、内联函数

（一）其它名称

1.内联函数

2.在线函数

3.编译时期展开函数

（二）怎么写一个内联函数

inline声明和定义都需要添加在类中，当一个函数的声明和定义放在一起的时候，默认这个函数是内联函数

（三）内联函数有什么用

简单的逻辑写在内联函数中，可以有效提高程序的执行速度

（四）内联函数的注意事项

switch for while do while这种较为复杂的逻辑不要放在内联函数中

代码尽量不要超过10行

（五）内联的优缺点

用空间换时间

实现的是在编译时期，逻辑的复制粘贴，而不是函数跳转

四、宏

（一）作用

实现文本替换，可以一定程度上减少记忆负担

（二）语法

简单宏：

#define <宏名> <文本内容>

例：#define MINNUMBER 0.01

带参：

#define 宏名 (参数列表）文本内容

例：#define function(x) x*x

（三）分类

1.简单宏

添加宏：#define 宏名文本内容

2.带参数宏

添加宏：#define 宏名（参数列表）文本内容

在使用宏的时候将实参（数或者变量）传给形参

（四）卸载宏

#undef 被卸载宏名

五、别名

数据类别名

typedef ：为数据类型取别名（将复杂的数据类型修改为简单易读的名称）

六、作用域

（一）全局域

1.函数：

全局函数

2.变量：

全局变量：可以不初始化，系统会帮助初始化，但在实际项目开发中，建议程序员手动初始化

3.如果存在命名冲突怎么解决？

添加命名空间namespace全局变量

（二）成员域

1.函数：

成员函数：如果成员函数的声明和定义放在了一起，这个成员函数将被处理为内联函数

2.变量：

成员变量（成员属性）：可以不初始化，系统会帮助初始化，但在实际项目开发中，建议程序员手动初始化

（三）局部域

变量：局部变量，必须初始化

（四）语句域

if...else while for do...while 循环中创建的变量

{ }

七、随机数

1.导入头文件

2.添加随机种子

3.使用随机数

参考源码：

面向对象编程（OOP）

（一）什么是面向对象？

OOP——Object Oriented Programming。

面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

对象的含义是指具体的某一个事物，即在现实生活中能够看得见摸得着的事物。在面向对象程序设计中，对象所指的是计算机系统中的某一个成分。在面向对象程序设计中，对象包含两个含义，其中一个是数据，另外一个是动作。对象则是数据和动作的结合体。对象不仅能够进行操作，同时还能够及时记录下操作结果。

（二）优点

扩展数据类型，更符合现实生活的思考方式。

（三）类

1.实例化

通过类创造出一个对象的过程

2.成员

（1）成员属性

成员属性可以不手动初始化，原因：因为每个类都存在构造函数。

例：int number；

（2）成员函数

普通成员函数

注意：如果成员函数的声明和定义放在一起，则这个函数被称为内联函数

特殊成员函数：

分类
- 构造函数
  - 分类
    - 隐式构造
      - 语法：类名（）{}
    - 显式构造
      - 可以被重载
      - 成员属性初始化方式
        
        类名（参数列表） { 成员属性=值； }
        
        列表初始化
        
        类名（参数列表）：成员属性1（值1），成员属性2（值2）{}
    - 委托构造
      - 一个构造委托另外一个构造函数代为调用类名（参数）：类名（委托的构造函数实参）
        
        A(int i):A("Hello"){}
- 拷贝构造函数
  - 应用场景
    - 一个对象赋值给另一个对象的时候
    - 当一个对象被当做函数参数进行传递的时候
    - 当一个对象被当函数返回值返回的时候
  - 语法
    - 原生语法
      - 类名（const 类名& 名称）
        
        User(User&)
    - 开发语法
      - 类名（const 类名 & 名称）
        
        User(const User& U)
  - 深拷贝和浅拷贝
    - 浅拷贝
      - 在常规开发环境下，不需要手动地给出拷贝构造函数，直接使用系统分配的隐式构造函数就可以了
    - 深拷贝
      - 在本类中，存在一个成员属性为一个指针，且，在构造函数中，初始化这个指针，是在堆区申请空间，且，在析构函数中释放了这个堆申请的空间
        
        原理：自己申请空间，但是存放被拷贝对象值
- 析构函数
  - 代表的是一个对象的消亡

3.常函数

示例展示：


    class A
    {
    public:
        int a = 8;
    };
    class U
    {
    public:
        U()
        {
            number = 0;
            str2 = "Yes";
        }
        void SetValue()
        {
            number = 100;
        }
        void GetValue() const//常函数：这个函数不可以修改本类成员属性
        {
            str2 = "No";        //会报错，因为不能修改本类成员属性
            string newstr = "OK";//可以修改自己函数内部的变量
            A aInstance;
            aInstance.a = 180;//可以修改,因为aInstance是自己函数内部的变量
        }
        int number;
        string str2;
    };

（四）特性

1.封装

封装
- 1.将成员绑定为一个整体（成员函数，成员属性），所以，类中的成员和成员之间不存在顺序结构 2.将绑定的成员划分权限
- 破坏权限
  - 私有化成员函数，公有化成员函数
  - 友元

2.继承

作用：实现代码复用
分类
- 单继承
- 多继承
  - 菱形继承
    - 二义性
    - 浪费空间
继承访问修饰符

3.多态

作用：方便开发
静态多态
- 成员函数重载
动态多态
- 发生前提
  - 继承关系
  - 子类重写父类的虚函数
  - 发生在堆区
- 父类类型指针，存放子类类型对象，调用父类函数，展现子类形态

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/917603