进击的荆棘头像
Linux网络——Socket编程UDP封面图

Linux网络——Socket编程UDP

💁‍♂️个人主页 :进击的荆棘

👇作者其它专栏:

🧮数据结构与算法《数据结构与算法》
算法《算法》
C++《C++》
🐧Linux《Linux系统》《Linux网络》
MySQL《MySQL》

目录

1.V1 Echo Server

2.V2 DictServer

3.V3 简单聊天室

4.附录


1.V1 Echo Server

简单的回显服务器和客户端代码

UdpServer.hpp

#pragma once
#include <sys/socket.h>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include "Log.hpp"

using namespace LogModule;
using func_t=std::function<std::string(const std::string&)>;

const int defaultfd = -1;

class UdpServer
{
public:
    // UdpServer(uint16_t port, const std::string ip)
    UdpServer(uint16_t port,func_t func)
        : _sockfd(defaultfd), _port(port), _isrunnig(false),_func(func)
    {
    }
    void Init()
    {
        // 打开网络文件
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd == -1)
        {
            Log(Level::FATAL) << "socket error";
            exit(1);
        }
        Log(Level::DEBUG) << "socket success";

        // 将ip和端口号绑定到一起
        // 填充sockaddr_in结构体
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        // 端口号
        local.sin_port = htons(_port);
        // ip地址转换 本地->网络序列   从“点分十进制”-> uint32_t
        // local.sin_addr.s_addr = inet_addr(_ip.c_str());
        local.sin_addr.s_addr=INADDR_ANY;
        int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n == -1)
        {
            Log(Level::FATAL) << "bind error";
            exit(2);
        }
        Log(Level::INFO) << "bind success,sockfd:" << _sockfd;
    }
    void Start()
    {
        _isrunnig = true;
        while (_isrunnig)
        {
            char buffer[1024];
            struct sockaddr_in remo;
            socklen_t len = sizeof(remo);

            int n = recvfrom(_sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&remo, &len);
            if (n > 0)
            {
                buffer[n] = 0;
                int remo_port=ntohs(remo.sin_port);
                std::string remo_ip=inet_ntoa(remo.sin_addr);
                Log(Level::DEBUG)<<"["<<remo_ip<<":"<<remo_port<<"]#"<<buffer;

                // std::string message = "server echo:";
                // message += buffer;
                std::string ret=_func(buffer);
                sendto(_sockfd, ret.c_str(), ret.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
            }
        }
    }
    ~UdpServer() {}

private:
    int _sockfd;
    uint16_t _port;
    // std::string _ip;
    bool _isrunnig;
    func_t _func;
};

UdpClient.cc

#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <cstring>
#include <netinet/in.h>

// ./udpclient ip port
int main(const int argc, const char *argv[])
{
    if (argc != 3)
    {
        std::cerr << "Usage: " <<argv[0]<<"ip port"<<std::endl;
        exit(1);
    }
    std::string server_ip = argv[1];
    int server_port = std::stoi(argv[2]);

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    // 将ip和端口号绑定
    // 但client不需要显示bind,因为只要确保能唯一标识一个进程就行
    // OS知道ip,首次使用bind时,会动态分配端口号
    struct sockaddr_in remo;
    memset(&remo, 0, sizeof(remo));
    remo.sin_family = AF_INET;
    remo.sin_addr.s_addr = inet_addr(server_ip.c_str());
    remo.sin_port = htons(server_port);

    while (true)
    {
        std::cout << "Please enter:";
        std::string input;
        getline(std::cin, input);

        int n = sendto(sockfd, input.c_str(), input.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
        (void)n;
        char buffer[1024];
        socklen_t len = sizeof(remo);
        int m = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&remo, &len);
        if (m > 0)
        {
            buffer[m] = 0;
            std::cout << buffer << std::endl;
        }
    }
    return 0;
}

注:

client端不用显示bind

2.V2 DictServer

实现一个简单的英译汉网络字典

dictionary.txt

banana: 香蕉
orange: 橙子
grape: 葡萄
watermelon: 西瓜
strawberry: 草莓
peach: 桃子
pear: 梨
lemon: 柠檬
mango: 芒果
cherry: 樱桃
car: 汽车
bicycle: 自行车
train: 火车
hello: 
: 你好
airplane: 飞机
book: 书
computer: 电脑
phone: 电话
water: 水
fire: 火
mountain: 山

Dict.hpp

#pragma once 
#include <string>
#include <fstream>
#include <unordered_map>
#include "Addr.hpp"
#include "Log.hpp"

using namespace LogModule;

const std::string defaultdict="./dictionary.txt";
const std::string spe=": ";

class Dict{
public:
    Dict(const std::string &path=defaultdict):_dict_path(path)
    {}
    void Load(){
        std::ifstream in(_dict_path);
        if(!in.is_open()){
            Log(Level::DEBUG)<<"打开字典错误";
            exit(1);
        }

        std::string line;
        while(std::getline(in,line)){
            int pos=line.find(spe);
            if(pos==std::string::npos){
                Log(Level::WARNING)<<"不符合规格,"<<line;
                continue;
            }

            std::string english=line.substr(0,pos);
            std::string chinese=line.substr(pos+spe.size());

            //若中文或英文为空也不符合规格
            if(english.empty()||chinese.empty()){
                Log(Level::WARNING)<<"不符合规格"<<line;
                continue;
            }
            _dict.insert(std::make_pair(english,chinese));
            Log(Level::INFO)<<"加载"<<line<<" 成功";
        }

        in.close();
    }
    std::string Translate(const std::string &word,Addr &client){
        auto iter=_dict.find(word);
        if(iter==_dict.end()){
            Log(Level::INFO)<<"找不到:"<<word;
            return "NONE";
        }

        Log(Level::INFO)<<"开始翻译:["<<client.Ip()<<":"<<client.Port()<<"]"<<word;
        return iter->second;
    }
    ~Dict(){}
private:
    std::string _dict_path;
    std::unordered_map<std::string,std::string> _dict;
};

UdpServer.hpp

#pragma once
#include <sys/socket.h>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include "Log.hpp"
#include "Addr.hpp"

using namespace LogModule;
using func_t=std::function<std::string(const std::string&,Addr &)>;

const int defaultfd = -1;

class UdpServer
{
public:
    // UdpServer(uint16_t port, const std::string ip)
    UdpServer(uint16_t port,func_t func)
        : _sockfd(defaultfd), _port(port), _isrunnig(false),_func(func)
    {
    }
    void Init()
    {
        // 打开网络文件
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd == -1)
        {
            Log(Level::FATAL) << "socket error";
            exit(1);
        }
        Log(Level::DEBUG) << "socket success";

        // 将ip和端口号绑定到一起
        // 填充sockaddr_in结构体
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        // 端口号
        local.sin_port = htons(_port);
        // ip地址转换 本地->网络序列   从“点分十进制”-> uint32_t
        // local.sin_addr.s_addr = inet_addr(_ip.c_str());
        local.sin_addr.s_addr=INADDR_ANY;
        int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n == -1)
        {
            Log(Level::FATAL) << "bind error";
            exit(2);
        }
        Log(Level::INFO) << "bind success,sockfd:" << _sockfd;
    }
    void Start()
    {
        _isrunnig = true;
        while (_isrunnig)
        {
            char buffer[1024]={0};
            struct sockaddr_in remo;
            socklen_t len = sizeof(remo);

            int n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr *)&remo, &len);
            if (n > 0)
            {
                buffer[n] = 0;
                Addr peer(remo);
                Log(Level::DEBUG)<<"["<<peer.Ip()<<":"<<peer.Port()<<"]#"<<buffer;

                // std::string message = "server echo:";
                // message += buffer;
                std::string ret=_func(buffer,peer);
                sendto(_sockfd, ret.c_str(), ret.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
            }
        }
    }
    ~UdpServer() {}

private:
    int _sockfd;
    uint16_t _port;
    // std::string _ip;
    bool _isrunnig;
    func_t _func;
};

UdpServer.cc

#include <iostream>
#include <memory>
#include "UdpServer.hpp"
#include "Dict.hpp"

std::string defaulthandler(const std::string &message){
    std::string ret="hello ";
    ret+=message;
    return ret;
}

//  ./udpserver port
int main(const int argc, const char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " port" << std::endl;
        exit(1);
    }

    // std::string ip = argv[1];
    int port = std::stoi(argv[1]);

    Dict r;
    r.Load();

    std::unique_ptr<UdpServer> up = std::make_unique<UdpServer>(port,[&r](const std::string &word,Addr &client)->std::string{
        return r.Translate(word,client);
    });
    up->Init();
    up->Start();
    return 0;
}

UdpClient.cc

#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <cstring>
#include <netinet/in.h>

// ./udpclient ip port
int main(const int argc, const char *argv[])
{
    if (argc != 3)
    {
        std::cerr << "Usage: " <<argv[0]<<"ip port"<<std::endl;
        exit(1);
    }
    std::string server_ip = argv[1];
    int server_port = std::stoi(argv[2]);

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    // 将ip和端口号绑定
    // 但client不需要显示bind,因为只要确保能唯一标识一个进程就行
    // OS知道ip,首次使用bind时,会动态分配端口号
    struct sockaddr_in remo;
    memset(&remo, 0, sizeof(remo));
    remo.sin_family = AF_INET;
    remo.sin_addr.s_addr = inet_addr(server_ip.c_str());
    remo.sin_port = htons(server_port);

    while (true)
    {
        std::string input;
        std::cout << "Please enter#";
        std::getline(std::cin, input);

        //排除输入空行的情况
        if(input.empty()) continue;

        int n = sendto(sockfd, input.c_str(), input.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
        (void)n;
        char buffer[1024]={0};
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int m = recvfrom(sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr *)&peer, &len);
        if (m > 0)
        {
            buffer[m] = 0;
            std::cout << buffer << std::endl;
        }
    }
    return 0;
}

Addr.hpp

#pragma once
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

class Addr
{
public:
    Addr(struct sockaddr_in addr) : _addr(addr)
    {
        _ip=inet_ntoa(_addr.sin_addr);
        _port=ntohs(addr.sin_port);
    }
    std::string Ip() { return _ip; }
    uint16_t Port() { return _port; }

    ~Addr() {}

private:
    struct sockaddr_in _addr;
    std::string _ip;
    uint16_t _port;
};

3.V3 简单聊天室

Router.hpp

#pragma once
#include <vector>
#include "ThreadPool.hpp"
#include "Addr.hpp"

using namespace ThreadPoolModule;

class Router
{
private:
    bool IsExist(Addr &peer)
    {
        for (auto user : _online_user)
        {
            if (peer == user)
            {
                return true;
            }
        }
        return false;
    }
    void AddUser(Addr &peer)
    {
        // 只有不存在时才会添加
        _online_user.push_back(peer);
        Log(Level::INFO) << "添加用户成功," << peer.StringAddr();
    }
    void DeleteUser(Addr &peer)
    {
        // 只有用户存在时,才能删除
        for (auto iter = _online_user.begin(); iter != _online_user.end(); iter++)
        {
            if (*iter == peer)
            {
                _online_user.erase(iter);
                break;
            }
        }

        Log(Level::INFO)<<"删除用户成功,"<<peer.StringAddr();
    }

public:
    void Message(int sockfd, const std::string &message,Addr &peer)
    {
        if (!IsExist(peer))
        {
            AddUser(peer);
        }

        // ip:port# message
        std::string ret = "["+peer.StringAddr() + "] " + message;

        //转发给所有用户
        for(auto user:_online_user)
            sendto(sockfd, ret.c_str(), ret.size(), 0, (const struct sockaddr *)&(user.NetAddr()), sizeof(user.NetAddr()));

        if (message == "QUIT")
        {
            DeleteUser(peer);
        }
    }

private:
    std::vector<Addr> _online_user;
};

UdpServer.hpp

#pragma once
#include <sys/socket.h>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include "Log.hpp"
#include "Addr.hpp"

using namespace LogModule;
using func_t=std::function<void(int,const std::string&,Addr &)>;

const int defaultfd = -1;

class UdpServer
{
public:
    // UdpServer(uint16_t port, const std::string ip)
    UdpServer(uint16_t port,func_t func)
        : _sockfd(defaultfd), _port(port), _isrunnig(false),_func(func)
    {
    }
    void Init()
    {
        // 打开网络文件
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd == -1)
        {
            Log(Level::FATAL) << "socket error";
            exit(1);
        }
        Log(Level::DEBUG) << "socket success";

        // 将ip和端口号绑定到一起
        // 填充sockaddr_in结构体
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        // 端口号
        local.sin_port = htons(_port);
        // ip地址转换 本地->网络序列   从“点分十进制”-> uint32_t
        // local.sin_addr.s_addr = inet_addr(_ip.c_str());
        local.sin_addr.s_addr=INADDR_ANY;
        int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n == -1)
        {
            Log(Level::FATAL) << "bind error";
            exit(2);
        }
        Log(Level::INFO) << "bind success,sockfd:" << _sockfd;
    }
    void Start()
    {
        _isrunnig = true;
        while (_isrunnig)
        {
            char buffer[1024]={0};
            struct sockaddr_in remo;
            socklen_t len = sizeof(remo);

            int n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr *)&remo, &len);
            if (n > 0)
            {
                buffer[n] = 0;
                Addr peer(remo);
                Log(Level::DEBUG)<<"["<<peer.Ip()<<":"<<peer.Port()<<"]#"<<buffer;

                // std::string message = "server echo:";
                // message += buffer;
                _func(_sockfd,buffer,peer);
                // sendto(_sockfd, ret.c_str(), ret.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
            }
        }
    }
    ~UdpServer() {}

private:
    int _sockfd;
    uint16_t _port;
    // std::string _ip;
    bool _isrunnig;
    func_t _func;
};

Addr.hpp

#pragma once
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string>

class Addr
{
public:
    Addr(struct sockaddr_in addr) : _addr(addr)
    {
        //这种转化方式不安全,因为这个ip的地址被存在静态区,若使用多个转化,则地址会全一样
        // _ip=inet_ntoa(_addr.sin_addr);
        char ipbuffer[64];
        inet_ntop(AF_INET,&_addr.sin_addr,ipbuffer,sizeof(ipbuffer));
        _port=ntohs(addr.sin_port);
    }
    //主机转网络
    Addr(std::string ip,uint16_t port):_ip(ip),_port(port)
    {
        memset(&_addr,0,sizeof(_addr));
        _addr.sin_family=AF_INET;        
        _addr.sin_port=htons(_port);
        inet_pton(AF_INET,_ip.c_str(),&_addr.sin_addr);
    }
    std::string Ip() { return _ip; }
    uint16_t Port() { return _port; }
    const struct sockaddr_in& NetAddr(){
        return _addr;
    }
    const std::string StringAddr(){
        return _ip+":"+std::to_string(_port);
    }
    bool operator==(const Addr& peer){
        return peer._ip==_ip&&peer._port==_port;
    }
    ~Addr() {}

private:
    struct sockaddr_in _addr;
    std::string _ip;
    uint16_t _port;
};

●重载==,方便对是否是同一个用户进行比较

UdpServer.cc

#include <iostream>
#include <memory>
#include "UdpServer.hpp"
#include "Router.hpp"

using task_t=std::function<void()>;

std::string defaulthandler(const std::string &message){
    std::string ret="hello ";
    ret+=message;
    return ret;
}

//  ./udpserver port
int main(const int argc, const char *argv[])
{
    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " port" << std::endl;
        exit(1);
    }

    // std::string ip = argv[1];
    int port = std::stoi(argv[1]);

    //设置路由
    Router r;

    auto tp=ThreadPool<task_t>::GetInstance();

    std::unique_ptr<UdpServer> up=std::make_unique<UdpServer>(port,[&r,&tp](int sockfd,const std::string &message,Addr &peer){
        task_t t=std::bind(&Router::Message,&r,sockfd,message,peer);
        tp->EnQueue(t);
    });

    // std::unique_ptr<UdpServer> up = std::make_unique<UdpServer>(port,[&r](int sockfd,const std::string& message,Addr &peer){
    //     r.Message(sockfd,message,peer);
    // });

    up->Init();
    up->Start();
    return 0;
}

UdpClient.cc

#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <cstring>
#include <netinet/in.h>
#include "Thread.hpp"

using namespace ThreadModule;

int sockfd = -1;
std::string server_ip;
uint16_t server_port = 0;
pthread_t id;

void Recv()
{
    while (true)
    {
        char buffer[1024] = {0};
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int m = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
        if (m > 0)
        {
            buffer[m] = 0;
            std::cerr<< buffer << std::endl;
        }
    }
}

void Sendto()
{
    struct sockaddr_in remo;
    memset(&remo, 0, sizeof(remo));
    remo.sin_family = AF_INET;
    remo.sin_addr.s_addr = inet_addr(server_ip.c_str());
    remo.sin_port = htons(server_port);

    // 上线自动发送online
    const std::string defaultmessage = "online";
    sendto(sockfd, defaultmessage.c_str(), defaultmessage.size(), 0, (struct sockaddr *)&remo, sizeof(remo));

    while (true)
    {
        std::string input;
        std::cout << "Please enter#";
        std::getline(std::cin, input);

        // 排除输入空行的情况
        if (input.empty())
            continue;

        int n = sendto(sockfd, input.c_str(), input.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
        (void)n;

        if (input == "QUIT")
        {
            pthread_cancel(id);
            break;
        }
    }
}

// ./udpclient ip port
int main(const int argc, const char *argv[])
{
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << "ip port" << std::endl;
        exit(1);
    }
    server_ip = argv[1];
    server_port = std::stoi(argv[2]);

    // 创建套接字
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    // 将ip和端口号绑定
    // 但client不需要显示bind,因为只要确保能唯一标识一个进程就行
    // OS知道ip,首次使用bind时,会动态分配端口号

    Thread recv(Recv);
    Thread sendto(Sendto);

    recv.Start();
    sendto.Start();

    id = recv.GetId();

    recv.Join();
    sendto.Join();

    return 0;
}

●UDP协议支持全双工,一个sockfd,既可以读取,有可以写入,对于客户端和服务端同样如此

●多线程客户端,同时读取和写入

4.附录

4.1地址转换函数

以下为IPv4的socket网络编程,sockaddr_in中的成员struct in_addr sin_addr表示32位的IP地址

但是我们通常用点分十进制的字符串表示IP地址,以下函数可以在字符串表示和in_addr表示之间转换

字符串转in_addr的函数:

in_addr转字符串的函数

其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void* addrptr

代码示例:

4.2关于inet_ntoa

inet_ntoa函数返回了一个char *,很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果。那么是否需要调用者手动释放呢?

man手册上说,inet_ntoa函数,是把这个结果放在了静态存储区,这个时候不需要我们手动释放

那么,若我们多次调用这个函数,会有什么结果?

运行结果如下:

因为inet_ntoa把结果放在自己内部的一个静态存储区,这样第二次调用的时候的结果会覆盖掉上一次的结果:

●若有多个线程调用inet_ntoa,是否会出现异常情况?

●在APUE中,明确提出inet_ntoa不是线程安全的函数

●但是在centos7上测试,并没有出现问题,可能是内部的实现加了互斥锁

●多线程环境下,推荐使用inet_ntop,这个函数由调用者提供一个缓冲区保存结果,可以规避线程安全问题

多线程调用inet_ntoa:

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
void *Func1(void *p)
{
    struct sockaddr_in *addr = (struct sockaddr_in *)p;
    while (1)
    {
        char *ptr = inet_ntoa(addr->sin_addr);
        printf("addr1: %s\n", ptr);
    }
    return NULL;
}
void *Func2(void *p)
{
    struct sockaddr_in *addr = (struct sockaddr_in *)p;
    while (1)
    {
        char *ptr = inet_ntoa(addr->sin_addr);
        printf("addr2: %s\n", ptr);
    }
    return NULL;
}
int main()
{
    pthread_t tid1 = 0;
    struct sockaddr_in addr1;
    struct sockaddr_in addr2;
    addr1.sin_addr.s_addr = 0;
    addr2.sin_addr.s_addr = 0xffffffff;
    pthread_create(&tid1, NULL, Func1, &addr1);
    pthread_t tid2 = 0;
    pthread_create(&tid2, NULL, Func2, &addr2);
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    return 0;
}

4.3remove_if样例

#include <iostream>
#include <list>
#include <memory>
#include <algorithm>

int main()
{
    std::list<std::shared_ptr<int>> ls;
    ls.push_back(std::make_shared<int>(1));
    ls.push_back(std::make_shared<int>(2));
    ls.push_back(std::make_shared<int>(3));
    ls.push_back(std::make_shared<int>(4));
    ls.push_back(std::make_shared<int>(4));
    ls.push_back(std::make_shared<int>(4));
    ls.push_back(std::make_shared<int>(5));
    ls.push_back(std::make_shared<int>(6));
    for (auto &v : ls)
    {
        std::cout << *v << std::endl;
    }
    std::cout << "aa: " << ls.size() << std::endl;
    std::cout << "\n";
    // int a = 3;
    int a = 4;
    auto pos = remove_if(ls.begin(), ls.end(), [&a](const std::shared_ptr<int> &elem) -> bool{
         return a == *elem; 
    });
    ls.erase(pos, ls.end());
    std::cout << "aa: " << ls.size() << std::endl;
    for (auto &v : ls)
    {
        std::cout << *v << std::endl;
    }
    return 0;
}
// remove_if()并不会实际移除序列[start, end)中的元素; 如果在⼀个容器上应⽤remove_if(), 
//容器的⻓度并不会改变, 所有的元素都还在容器⾥⾯(但是逻辑上已经⽆法访问).
//remove_if() 将所有应该移除的元素都移动到容器尾部并返回⼀个分界的迭代器.为了实际移除元素,
// 你必须对容器⾃⾏调⽤erase() 以擦除需要移除的元素

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/2501_93697341/article/details/170817473

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--