C++STL(string类)

最新推荐文章于 2024-10-02 22:25:35 发布
最新推荐文章于 2024-10-02 22:25:35 发布
阅读量418 收藏 9
点赞数 8
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57425280/article/details/136258026
版权

文章目录

1.string类的介绍

废话少说，不那么繁琐的介绍了！就是跟字符有关！

在使用string类时，必须包含#include头文件以及using namespace std;

  1. string是表示字符串的字符串类
  2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
  3. string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>string;
  4. 不能操作多字节或者变长字符的序列。

2.string的基本用法

在使用string类时，必须包含#include头文件以及using namespace std;

2.1 拷贝用法

在这里插入图片描述
更多用法可以进入网站：https://cplusplus.com/
在这里插入图片描述

2.2 遍历用法

①第一种遍历：for循环(下标+[])
在这里插入图片描述
注意：
在这里插入图片描述
②第二种遍历：迭代器
在这里插入图片描述
看上去好像第一种下标+[]更简单，不过这个迭代器才是主流，其可以遍历链表，顺序表等等！

当然迭代器还有反向迭代器

string::reverse_iterator it3=s3.rbegin();

在这里插入图片描述

③第三种遍历：范围for
在这里插入图片描述
其实这个范围for的底层是迭代器，所以说迭代器才是主流！

2.3 迭代器

在这里插入图片描述
当然也有const反向迭代器
const_reverse_iterator

2.4 容量

在这里插入图片描述

2.5 元素访问

在这里插入图片描述

2.6 元素修改

在这里插入图片描述

2.7 其他操作

在这里插入图片描述
在这里插入图片描述
其他类型的数据转为字符串，可以使用to_string
字符串转其他类型的数据，可以使用stod！
在这里插入图片描述

3.string类的底层（模拟实现）

3.1 搭个结构

class string1
{
public:
    string1(const char* str = " ")//(构造函数，函数的作用是构造一个string1对象)
        :_size(strlen(str))
    {
        _capacity = _size;
        _str = new char[_capacity + 1];
        strcpy(_str, str);
    }
    
 ~string1()//析构函数，清理资源
    {
        delete[] _str;
        _str = nullptr;
        _size = _capacity = 0;
        cout << "~string1(析构清理已完成)" << endl;
    }
private://成员变量
    char* _str;//字符串
    size_t _capacity;//容量
    size_t _size;//字符串的长度
public:
    static const int npos;//对于类型为 size_t 的元素具有最大可能值。
    //此值在字符串的成员函数中用作 len（或 sublen）参数的值时，表示“直到字符串的末尾”。
    };

3.2 拷贝构造

    string1(const string1& s) //(拷贝构造函数)s2(s1)
    {
        this->_str = new char[s._capacity + 1];
        strcpy(_str, s._str);
        _size = s._size;
        _capacity = s._capacity;
    }

3.3 操作符重载operator=，operator+=

  string1& operator=(const string1& s)//(为字符串分配一个新的值，替换当前内容) s1=s3
    {
        char* tmp = new char[s._capacity + 1];
        strcpy(tmp, _str);
        delete _str;
        _str = tmp;
        _size = s._size;
        _capacity = s._capacity;

        return *this;
    }
    
 string1& operator+=(char c)//通过在字符串的当前值末尾追加其他字符来扩展字符串：
    {
        push_back(c);
        return *this;
    }

3.4 resize

void string1::resize(size_t n, char c)//n<size,保留前n位删除别的；size<n<capacity,剩余部分插入\0；n>capacity,可以自定义后面插入什么字符
{
    if (n <= _size)
    {
        _str[n] = '\0';
        _size = n;
    }
    else
    {
        reserve(n);//更改容量（扩容，但不会缩容）
        for (size_t i = _size; i < n; i++)
        {
            _str[i] = c;
        }
        _str[n] = '\0';
        _size = n;
    }
}

3.5 reserve

void string1::reserve(size_t n)//更改容量（扩容，但不会缩容）
{
    if (n > _capacity)
    {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;

        _capacity = n;
    }
}

3.6 push_back

void string1::push_back(char c)//将字符 c 追加到字符串的末尾,只能追加单个字符。
{
    if (_size == _capacity)
    {
        reserve(_capacity == 0 ? 4 : 2 * _capacity);//如果一开始capacity就是0就没法搞了，所以要先用个三目
    }
    _str[_size] = c;
    ++_size;
    _str[_size] = '\0';
}

3.7 append

void string1::append(const char* str)//通过在字符串的当前值末尾追加其他字符来扩展字符串：允许追加多个参数值
{
    size_t len = strlen(str);
    if (_size + len > _capacity)
        reserve(_size + len);

    strcpy(_str + _size, str);
    _size = _size + len;
}

3.8 insert

void string1::insert(size_t pos, char c)//在某个位置插入一个字符
{
    assert(pos <= _size);

    // 扩容2倍
    if (_size == _capacity)
    {
        reserve(_capacity == 0 ? 4 : 2 * _capacity);
    }

    size_t end = _size + 1;
    while (end > pos)
    {
        _str[end] = _str[end - 1];
        --end;
    }

    _str[pos] = c;
    ++_size;
}

void string1::insert(size_t pos, const char* str)//在某个位置插入字符串
{
    assert(pos <= _size);
    size_t len = strlen(str);
    if (_size + len > _capacity)
    {
        // 扩容
        reserve(_size + len);
    }

    size_t end = _size + len;
    while (end > pos + len - 1)
    {
        _str[end] = _str[end - len];
        end--;
    }

    strncpy(_str + pos, str, len);
    _size += len;
}

3.9 erase

void string1::erase(size_t pos, size_t len)//擦除部分字符串，减少其长度：
{
    assert(pos < _size);

    if (len == npos || len >= _size - pos)
    {
        _str[pos] = '\0';
        _size = pos;
    }
    else
    {
        strcpy(_str + pos, _str + pos + len);
        _size = _size - len;
    }
}

3.10 等等等等，这里附上完整代码

string.h:

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
using namespace std;
#include <assert.h>

namespace my_string
{
    class string1
    {
        friend ostream& operator<<(ostream& _cout, const string& s)
        {
            for (auto ch : s)
            {
                _cout << ch;
            }
            return _cout;
        }

        friend istream& operator>>(istream& _cin, string& s)
        {
            s.clear();

            char ch;
            //in >> ch;
            ch = _cin.get();
            char buff[128];
            size_t i = 0;
            while (ch != ' ' && ch != '\n')
            {
                buff[i++] = ch;
                // [0,126]
                if (i == 127)
                {
                    buff[127] = '\0';
                    s += buff;
                    i = 0;
                }
                ch = _cin.get();
            }

            if (i > 0)
            {
                buff[i] = '\0';
                s += buff;
            }
            return _cin;
        }

    public:
        typedef char* iterator;
        typedef const char* const_iterator;
    public:
        string1(const char* str = " ")//(构造函数，函数的作用是构造一个string1对象)
            :_size(strlen(str))
        {
            _capacity = _size;
            _str = new char[_capacity + 1];
            strcpy(_str, str);
        }

        string1(const string1& s) //(拷贝构造函数)s2(s1)
        {
            this->_str = new char[s._capacity + 1];
            strcpy(_str, s._str);
            _size = s._size;
            _capacity = s._capacity;
        }

        string1& operator=(const string1& s)//(为字符串分配一个新的值，替换当前内容) s1=s3
        {
            char* tmp = new char[s._capacity + 1];
            strcpy(tmp, _str);
            delete _str;
            _str = tmp;
            _size = s._size;
            _capacity = s._capacity;

            return *this;
        }

        ~string1()//析构函数，清理资源
        {
            delete[] _str;
            _str = nullptr;
            _size = _capacity = 0;
            cout << "~string1(析构清理已完成)" << endl;
        }
        //
        // iterator

        const_iterator begin() const
        {
            return _str;
        }

        const_iterator end() const
        {
            return _str + _size;
        }

        iterator begin()
        {
            return _str;
        }

        iterator end()
        {
            return _size + _str;
        }
        /
        // modify
        void push_back(char c);

        string1& operator+=(char c)//通过在字符串的当前值末尾追加其他字符来扩展字符串：
        {
            push_back(c);
            return *this;
        }

        void append(const char* str);

        string1& operator+=(const char* str)
        {
            append(str);
            return *this;
        }

        void clear();
        void swap(string1& s);
        const char* c_str()const //用于返回一个指向以空字符结尾的字符数组（C风格字符串）的指针。
        {
            return _str;
        }
        /
        // capacity
        size_t size()const
        {
            return _size;
        }

        size_t capacity()const
        {
            return _capacity;
        }

        bool empty()const
        {
            if (_size == 0)
                return 0;
            else
                return 1;
        }
        void resize(size_t n, char c = '\0');
        void reserve(size_t n);
        /
        // access
        char& operator[](size_t pos)//返回字符串中pos位置处字符的引用
        {
            assert(pos < _size);
            return _str[pos];
        }

        const char& operator[](size_t pos)const
        {
            assert(pos < _size);
            return _str[pos];
        }
        public:
        /
        //relational operators
        bool operator<(const string1& s);
        bool operator<=(const string1& s);
        bool operator>(const string1& s);
        bool operator>=(const string1& s);
        bool operator==(const string1& s);
        bool operator!=(const string1& s);

        // 返回c在string1中第一次出现的位置
        size_t find(char c, size_t pos = 0) const;
        // 返回子串s在string1中第一次出现的位置
        size_t find(const char* s, size_t pos = 0) const;
        // 在pos位置上插入字符c/字符串str，并返回该字符的位置
        void insert(size_t pos, char c);
        void insert(size_t pos, const char* str);
        // 删除pos位置上的元素，并返回该元素的下一个位置
        void erase(size_t pos, size_t len = npos);
        string substr(size_t pos = 0, size_t len = npos);
    private://成员变量
        char* _str;//字符串
        size_t _capacity;//容量
        size_t _size;//字符串的长度

    public:
        static const int npos;//对于类型为 size_t 的元素具有最大可能值。
        //此值在字符串的成员函数中用作 len（或 sublen）参数的值时，表示“直到字符串的末尾”。

    };
    extern const int npos;
}

string.cpp:

#include "string.h"
#define _CRT_SECURE_NO_WARNINGS 1
using namespace my_string;
const int string1::npos = -1;

void string1::resize(size_t n, char c)//n<size,保留前n位删除别的；size<n<capacity,剩余部分插入\0；n>capacity,可以自定义后面插入什么字符
{
    if (n <= _size)
    {
        _str[n] = '\0';
        _size = n;
    }
    else
    {
        reserve(n);//更改容量（扩容，但不会缩容）
        for (size_t i = _size; i < n; i++)
        {
            _str[i] = c;
        }
        _str[n] = '\0';
        _size = n;
    }
}

void string1::reserve(size_t n)//更改容量（扩容，但不会缩容）
{
    if (n > _capacity)
    {
        char* tmp = new char[n + 1];
        strcpy(tmp, _str);
        delete[] _str;
        _str = tmp;

        _capacity = n;
    }
}

void string1::push_back(char c)//将字符 c 追加到字符串的末尾,只能追加单个字符。
{
    if (_size == _capacity)
    {
        reserve(_capacity == 0 ? 4 : 2 * _capacity);//如果一开始capacity就是0就没法搞了，所以要先用个三目
    }
    _str[_size] = c;
    ++_size;
    _str[_size] = '\0';
}

void string1::append(const char* str)//通过在字符串的当前值末尾追加其他字符来扩展字符串：允许追加多个参数值
{
    size_t len = strlen(str);
    if (_size + len > _capacity)
        reserve(_size + len);

    strcpy(_str + _size, str);
    _size = _size + len;
}

void string1::insert(size_t pos, char c)//在某个位置插入一个字符
{
    assert(pos <= _size);

    // 扩容2倍
    if (_size == _capacity)
    {
        reserve(_capacity == 0 ? 4 : 2 * _capacity);
    }

    size_t end = _size + 1;
    while (end > pos)
    {
        _str[end] = _str[end - 1];
        --end;
    }

    _str[pos] = c;
    ++_size;
}

void string1::insert(size_t pos, const char* str)//在某个位置插入字符串
{
    assert(pos <= _size);
    size_t len = strlen(str);
    if (_size + len > _capacity)
    {
        // 扩容
        reserve(_size + len);
    }

    size_t end = _size + len;
    while (end > pos + len - 1)
    {
        _str[end] = _str[end - len];
        end--;
    }

    strncpy(_str + pos, str, len);
    _size += len;
}

void string1::erase(size_t pos, size_t len)//擦除部分字符串，减少其长度：
{
    assert(pos < _size);

    if (len == npos || len >= _size - pos)
    {
        _str[pos] = '\0';
        _size = pos;
    }
    else
    {
        strcpy(_str + pos, _str + pos + len);
        _size = _size - len;
    }
}

void string1::swap(string1& s)
{
    std::swap(_str, s._str);
    std::swap(_size, s._size);
    std::swap(_capacity, s._capacity);
}

size_t string1::find(char ch, size_t pos) const
{
    assert(pos < _size);

    for (size_t i = pos; i < _size; i++)
    {
        if (_str[i] == ch)
            return i;
    }

    return npos;
}

size_t string1::find(const char* sub, size_t pos) const
{
    assert(pos < _size);

    const char* p = strstr(_str + pos, sub);
    if (p)
    {
        return p - _str;
    }
    else
    {
        return npos;
    }
}

string string1::substr(size_t pos, size_t len)
{
    string sub;
    //if (len == npos || len >= _size-pos)
    if (len >= _size - pos)
    {
        for (size_t i = pos; i < _size; i++)
        {
            sub += _str[i];
        }
    }
    else
    {
        for (size_t i = pos; i < pos + len; i++)
        {
            sub += _str[i];
        }
    }

    return sub;
}

void string1::clear()
{
    _size = 0;
    _str[_size] = '\0';
}


bool string1::operator>(const string1& s) {
    int i = 0;
    while (_str[i] == s._str[i] && i < _size) {
        //当两个字符串字符相等时进入循环
        i++;
    }
    //不相等或遍历完了_str时退出循环
    if (i == _size) {
        //表示_str遍历完了,则肯定不大于
        return false;
    }
    return _str[i] > s._str[i] ? true : false;
}

bool string1::operator==(const string1& s) {
    int i = 0;
    while (_str[i] == s._str[i] && i < _size) {
        i++;
    }
    //遍历两个字符串，如果遍历完了，则表示相等
    if (i == _size && s._str[i] == '\0') {
        return true;
    }
    else {
        return false;
    }
}


bool string1::operator>=(const string1& s) {
    if (*this > s || *this == s) {
        return true;
    }
    return false;
}

bool string1::operator<(const string1& s) {
    if (!(*this >= s)) {
        return true;
    }
    return false;
}

bool string1::operator<=(const string1& s) {
    if (*this > s) {
        return false;
    }
    return true;
}

bool string1::operator!=(const string1& s) {
    if (*this == s) {
        return false;
    }
    return true;
}

main.cpp:

#define _CRT_SECURE_NO_WARNINGS 1

#include <iostream>
#include "string.h"
using namespace my_string;

void test_string1()
{
	string1 s1("hello world");
	string1 s2;
	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;

	for (size_t i = 0; i < s1.size(); i++)
	{
		s1[i]++;
	}
	cout << endl;

	// s1[100];

	for (size_t i = 0; i < s1.size(); i++)
	{
		cout << s1[i] << " ";
	}
	cout << endl;

	const string1 s3("xxxx");
	for (size_t i = 0; i < s3.size(); i++)
	{
		//s3[i]++;
		cout << s3[i] << " ";
	}
	cout << endl;

}

void test_string2()
{
	string1 s3("hello world");
	for (auto ch : s3)
	{
		cout << ch << " ";
	}
	cout << endl;

	string1::iterator it3 = s3.begin();
	while (it3 != s3.end())
	{
		*it3 -= 1;
		cout << *it3 << " ";
		++it3;
	}
	cout << endl;

	const string1 s4("xxxx");
	string1::const_iterator it4 = s4.begin();
	while (it4 != s4.end())
	{
		//*it4 += 3;
		cout << *it4 << " ";
		++it4;
	}
	cout << endl;

	for (auto ch : s4)
	{
		cout << ch << " ";
	}
	cout << endl;
}

void test_string3()
{
	string1 s3("hello world");
	s3.push_back('1');
	s3.push_back('2');
	cout << s3.c_str() << endl;
	s3 += 'x';
	s3 += "yyyyyy";
	cout << s3.c_str() << endl;

	string1 s4("hello string");
	s4.insert(5, 't');
	cout << s4.c_str() << endl;

	string1 s5("hello string");
	s5.insert(0, "safsfds");
	cout << s5.c_str() << endl;
}

void test_string4()
{
	string1 s1("hello world");
	cout << s1.c_str() << endl;

	s1.erase(6, 3);
	cout << s1.c_str() << endl;

	s1.erase(6, 30);
	cout << s1.c_str() << endl;

	s1.erase(3);
	cout << s1.c_str() << endl;

	string1 s2("hello world");
	cout << s2.c_str() << endl;

	s2.resize(5);
	cout << s2.c_str() << endl;

	s2.resize(20, 'x');
	cout << s2.c_str() << endl;
}

void test_string5()
{
	string1 s1("hello world");
	cout << s1.c_str() << endl;

	string1 s2(s1);
	cout << s2.c_str() << endl;

	s1[0] = 'x';

	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;

	string1 s3("xxxxx");
	s1 = s3;

	cout << s1.c_str() << endl;
	cout << s3.c_str() << endl;
}

void test_string6()
{
	string1 s1("hello world");
	cout << s1.c_str() << endl;

	s1.insert(6, "xxx");
	cout << s1.c_str() << endl;

	string1 s2("xxxxxxx");

	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;
	swap(s1, s2);
	s1.swap(s2);
	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;
}

void test_string7()
{
	string url1("https://legacy.cplusplus.com/reference/string/string/substr/");
	string url2("http://www.baidu.com/s?ie=utf-8&f=8&rsv_bp=1&rsv_idx=1&tn=65081411_1_oem_dg&wd=%E5%90%8E%E7%BC%80%20%E8%8B%B1%E6%96%87&fenlei=256&rsv_pq=0xc17a6c03003ede72&rsv_t=7f6eqaxivkivsW9Zwc41K2mIRleeNXjmiMjOgoAC0UgwLzPyVm%2FtSOeppDv%2F&rqlang=en&rsv_dl=ib&rsv_enter=1&rsv_sug3=4&rsv_sug1=3&rsv_sug7=100&rsv_sug2=0&rsv_btype=i&inputT=1588&rsv_sug4=6786");

	string protocol, domain, uri;
	size_t i1 = url1.find(':');
	if (i1 != string::npos)
	{
		protocol = url1.substr(0, i1 - 0);
		cout << protocol.c_str() << endl;
	}

	// strchar
	size_t i2 = url1.find('/', i1 + 3);
	if (i2 != string::npos)
	{
		domain = url1.substr(i1 + 3, i2 - (i1 + 3));
		cout << domain.c_str() << endl;

		uri = url1.substr(i2 + 1);
		cout << uri.c_str() << endl;
	}
	size_t i3 = url1.find("baidu");
	cout << i3 << endl;
}


void test_string8()
{
	string s1("hello world");
	string s2("hello world");

	cout << (s1 == s2) << endl;

	cout << ("hello world" == s2) << endl;
	cout << (s1 == "hello world") << endl;

	cout << s1 << endl;
	cout << s2 << endl;

	cin >> s1 >> s2;

	cout << s1 << endl;
	cout << s2 << endl;
}

void test_string9()
{
	string s1;

	cin >> s1;
	cout << s1.capacity() << endl;
}

void test_string10()
{
	string s1("hello world");
	string s2(s1);

	cout << s1 << endl;
	cout << s2 << endl;
}


int main()
{
	test_string1();
	printf("第一个测试\n");

	test_string2();
	printf("第二个测试\n");

	test_string3();
	printf("第三个测试\n");

	test_string4();
	 printf("第四个测试\n");

	test_string5();
	 printf("第五个测试\n");
	test_string6();
	 printf("第六个测试\n");

	test_string7();
	printf("第七个测试\n");

	test_string8();
	printf("第八个测试\n");

	test_string9();
	printf("第九个测试\n");

	test_string10();
	printf("第十个测试\n");
	return 0;
}
Chris·Bosh
关注
专栏目录
【C++STL详解 —— string类】
jokr_的博客
03-06 1642
string s();//构造一个空字符串//复制s所指向的字符序列//复制s所指向的字符序列的前n个字符//生成n个c字符的字符串//生成str的复制//复制str中字符位置pos开始并且跨越len个字符的部分。
【C++】string类
小羊的博客
08-06 3156
string类常用接口
C++ STL详解超全总结(快速入门STL)
热门推荐
行码棋
02-24 16万+
C++STL合集，包含vector，stack，queue，map，set，array，tuple，deque，priority_queue等诸多内容，全文上万字。
【C++STL】String类的常用函数用法总结
Zfox的博客
05-01 1280
对C++的string进行了简要介绍
C++——string类
2301_80342122的博客
09-14 1951
string属于，而不属于，STL也属于C++标准库string是管理字符的，用来string是，只是库直接给它了，直接了string的接口设计的非常的繁杂自定义类型实现流插入和流提取要，但这里在库里已经实现了指向的空间在堆上，可以动态增长。
C++ STL与string类
m0_72625526的博客
08-07 1548
C++ 标准库提供了一个名为的类，用于处理字符串。string类是std命名空间的一部分。string数组访问：访问数组元素时，是通过指针偏移和解引用来实现的。例如，arr[i]实际上是*(arr + i)，即从指针arr偏移i个元素后得到的地址的值。字符串访问：在string类中，operator[]是一个函数调用。每次使用s1[pos]时，实际上是调用了这个函数来返回字符串中位置pos的字符的引用。迭代器提供了统一的接口来遍历不同类型的容器（如数组、链表、树等），不需要知道容器的内部实现。
【C++】STL String
onlyongwang的博客
07-04 531
C++提供String 的模板类，可以很方便的处理字符串。
C++STL详解（一）—— string类
2021dragon的博客
06-14 6636
文章目录C++STL详解（一） —— sring类一、string的定义方式二、string的插入三、string的拼接四、string的删除五、string的查找六、string的比较七、string的替换八、string的交换九、string的大小和容量十、string中元素的访问十一、string中运算符的使用十二、string中与迭代器相关的函数 C++STL详解（一） —— sring类 本次内容大纲： 一、string的定义方式 string类实现了多个构造函数的重载，常用的构造函数如下： st
【C++ • STL】探究string的源码
m0_57388581的博客
09-26 2518
浅拷贝、浅拷贝、string的模拟实现（传统和现代）
C++STL之string的使用
weixin_47257473的博客
12-24 1163
本章主要介绍了C++中STL库中string的使用，一些常见的接口说明及使用，如常见的string的类对象构造，string类对象的容量操作，string类对象的访问和遍历操作，修改操作以及一些string类非成员的函数.
C++ STL string类 字符串处理函数 第二版
08-11
在C++编程中，STL（Standard Template Library...同时，理解C++内存管理、异常处理和模板也是掌握STL string类的重要方面。通过实践和调试`trim() 调试.cpp`这样的代码，可以加深对字符串操作的理解，并提升编程技巧。
string类的构造方法_String类重要吗_C++_STL_string_
09-30
标题中的“string类的构造方法”揭示了我们要探讨的核心内容——如何初始化和创建`std::string`对象。`std::string`类不仅在日常编程中频繁使用，而且在很多高级功能如正则表达式、文本处理等方面都有重要应用，因此...
第4章C++标准库STLstring类.ppt
11-13
C++标准库STLstring类 C++标准库STLstring类是C++标准库中的一个基本组件，提供了字符串处理的基本操作。下面是该类的详细知识点： 一、string类的基本概念 * string类是一个模板类basic_string的别名，定义在...
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1025
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 651
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 420
【代码】求n的阶乘的相反数（c语言）
C语言中的日志机制：打造全面强大的日志系统
极客代码
09-30 392
构建一个全面强大的日志机制对于软件开发至关重要。通过上述示例，你应该已经了解了如何在C语言中实现日志记录的不同方面。这种能力对于调试程序、监控应用程序状态和维护系统的稳定性非常有帮助。在软件开发中，良好的日志记录机制对于调试、监控程序状态和维护系统的稳定性至关重要。本文将介绍如何在C语言中构建一个全面强大的日志系统，并提供一些示例代码。实现日志文件的自动旋转，以便管理日志文件的大小。定义日志级别的宏，便于管理和调整日志输出。使用定义好的日志宏来记录日志。实现日志配置的读取和设置。1. 日志的基本概念。
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
静谧、淡雅
09-29 233
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
最新发布
weixin_45740473的博客
10-02 580
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
C++ STL String深度解析
"这篇文档是关于C++标准模板库(STL)中的`std::string`类的深入详解，由董波撰写。文章介绍了`std::string`的基本使用、成员函数、构造方法、重载运算符以及与算法的结合使用。" 在C++编程中，`std::string`是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Chris·Bosh

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值