C++中string类的模拟实现

char* _str = nullptr;
size_t _capacity = 0;
size_t _size = 0;
//这里可以直接给默认值，相当于定义,因为有const,只有整型可以
//static const size_t npos = -1;
static const size_t npos;

string类结构里有一个_str指针，指向存储字符的数组，_capacity表示当前string的空间大小，_size表示当前string中的有效元素个数，静态常量npos默认等于-1,表示整形的最大值。

2.默认成员函数

2.1.默认构造函数

//默认构造函数
string()
//直接给空指针在使用.c_str()时进行打印对空指针进行了解引用
:_str(new char[1] {'\0'})
//:_str(nullptr)
,_size(0)
,_capacity(0)
{}

//带参的构造
string(const char* str)
{
_size = strlen(str);
//_capacity不包含\0
_capacity = _size;
//开空间的时候多开一个用于存储\0
_str = new char[_capacity + 1];
strcpy(_str, str);
}

这里的默认构造函数不能给_str空指针，如果是个空串进行打印的话，会对空指针进行解引用会导致程序崩溃。因为要存一个'\0'，所以空串也要开一个空间。

这里可以把上述两个构造合成一个构造函数。

//将上述两个构造函数合并成一个全缺省的构造函数
string(const char* str = "")//空的常量字符串默认包含一个\0
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);//strcpy先拷贝再判断，会拷贝\0
}

2.2拷贝构造函数

1.传统写法

//传统写法
string(const string& s)
{
_str = new char[s._capacity + 1];    //多开一个空间给'\0'
strcpy(_str, s._str);                //拷贝数据
_size = s._size;
_capacity = s._capacity;
}

2.现代写法

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

//现代写法
string(const string& s)
{
string tmp(s._str);
swap(tmp);
}

这里调用库里面的交换函数，交换string结构里面的数据。然后在拷贝函数中用被拷贝的string对象s中的_str构造一个临时对象，然后进行交换，函数结束之后这个临时对象自动销毁，构造出一个与s一样的新对象。

2.3赋值运算符重载

1.写法1

string& operator=(const string& s)
{
if (this != &s)    //检测是否是自己给自己赋值
{
delete[] _str;    //释放原来对象的空间
_str = new char[s._capacity + 1];    //new一个和s一样大的空间
strcpy(_str, s._str);    //拷贝数据
_size = s._size;
_capacity = s._capacity;
}
return *this;
}

2.写法2

string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);
swap(tmp);
}

return *this;
}

这个和拷贝函数的现代写法思路一样。

3.写法3

string& operator=(string tmp)
{
swap(tmp);//这里虽然tmp被交换了，但是形参的改变不影响实参
return *this;
}

这里直接使用传值传参，然后进行交换，函数结束之后并不会影响实参。

2.4析构函数

~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;   
_size = 0;
_capacity = 0;
}
}

3.迭代器(Iterators)

// iterator
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}

const_iterator begin() const    //函数重载，重载迭代器用于const对象
{
return _str;
}

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

因为string的底层是利用数组进行存储的，所以这里直接利用原始指针作为迭代器即可，用两个typedef关键字将char*类型和const char*类型改为迭代器的名字。

4.string类的空间操作(Capacity)

4.1size()

size_t size() const
{
return _size;
}

4.2capacity()

size_t capacity() const
{
return _capacity;
}

4.3clear()

清除string对象里面的数据，但是这里不缩容_capacity不改变。

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

4.4reserve()

该函数在string.cpp里面实现的，所以加上了类域限定符.

void string::reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}

5.元素访问(Element access)

这里仅实现[]的重载。

char& operator[](size_t index)
{
assert(index < _size);

return _str[index];
}
const char& operator[](size_t index)const
{
assert(index < _size);

return _str[index];
}

6.string类的修改操作(Modifiers)

6.1push_back()

尾插一个字符.

void string::push_back(char c)
{
//扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}

_str[_size] = c;
++_size;
_str[_size] = '\0';
}

6.2append()

尾插一个字符串.这里扩容保持一个对齐的原则,如果需要的空间大于原来空间的两倍,则需要多少开多少,如果小于原来的两倍,则开2倍.

void string::append(const char* str)
{
size_t len = strlen(str);    //计算尾插的str大小
if (_size + len > _capacity)
{
//需要的空间大于原空寂的2倍，需要多少开多少，小于2倍开2倍
reserve((_size + len) > (2 * _capacity) ? (_size + len) : (2 * _capacity));
}

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

6.3operator+=()

+=运算符的重载实现能加一个字符,也能加一个字符串,复用上述两个接口进行实现.

string& string::operator+=(char c)
{
push_back(c);
return *this;
}
string& string::operator+=(const char* str)
{
append(str);
return *this;
}

6.4swap()

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

6.5insert()

// 在pos位置上插入字符c/字符串str
void string::insert(size_t pos, char c)
{
assert(pos <= _size);

if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
//这里用size_t类型头插会出错，因为end永远都小于不了0
//size_t end = _size;//从最后一个\0开始往后挪动数据
//用int end在与pos比较时会提升为size_t类型，也会出错
//int end = _size;
//while (end >= (int)pos)
//{
//_str[end + 1] = _str[end];
//end--;
//}

//挪动数据，_size处是\0,从后面的\0开始挪动
size_t end = _size + 1;
while (end > pos)    
{
_str[end] = _str[end - 1];
end--;
}

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

//在pos位置插入字符串
    void string::insert(size_t pos, const char* str)
{
assert(pos <= _size);

size_t len = strlen(str);
if (_size + len > _capacity)
{
//大于2倍，需要多少扩多少，小于2倍，扩2倍
reserve((_size + len) > (2 * _capacity) ? (_size + len) : (2 * _capacity));
}
        
        //挪动数据
size_t end = _size + len;
while (end >= pos + len - 1)
{
_str[end] = _str[end - len];
--end;
}
        //插入字符串
for (size_t i = 0; i < len; i++)
{
_str[pos + i] = str[i];
}

_size += len;
}

6.6 erase()

如果需要删除的len的长度大于从pos到最后位置的长度,则修正len之后进行删除.

// 删除pos位置上之后的len个元素
void string::erase(size_t pos, size_t len)
{
assert(pos < _size);
        
        //如果删除的元素个数大于从pos到最后的个数,修正一下len
if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
for (size_t i = pos + len; i <= _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
}

7.字符串操作(String operations)

7.1c_str()

这里返回string对象中的数组指针,可以说是返回C语言类型的字符串对象.

//返回string中的指向字符串的指针
const char* c_str() const
{
return _str;
}

7.2find()

// 返回c在string中第一次出现的位置
size_t string::find(char c, size_t pos) const
{
assert(pos < _size);

for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)
{
return i;
}
}
        
        //没找到返回最大的整数
return npos;
}

// 返回子串s在string中第一次出现的位置
size_t string::find(const char* s, size_t pos) const
{
assert(pos < _size);

        //调用库里面的strstr函数在自身中寻找子串
const char* ptr = strstr(_str + pos, s);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}

7.3substr()

//返回子串
string string::substr(size_t pos, size_t len) const
{
assert(pos < _size);
        
//len大于剩余字符的长度,更新一下len
if (len > _size - pos)
{
len = _size - pos;
}

string sub;
sub.reserve(len);
for (size_t i = 0; i < len; i++)
{
sub += _str[pos + i];
}

return sub;
}

8.非成员函数重载(Non-member function overloads)

8.1关系运算符(relational operators)

字符串的关系运算符与C语言中的compare()类似,这里直接复用库里面的compare()函数.

需要注意的是compare()函数是使用C语言中的字符串格式进行比较的,这里比较的是string对象中_str指向的数组.

//relational operators
bool operator<(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const string s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator<=(const string s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
bool operator>(const string s1, const string& s2)
{
return !(s1 <= s2);
}
bool operator>=(const string s1, const string& s2)
{
return !(s1 < s2);
}
bool operator!=(const string s1, const string& s2)
{
return !(s1 == s2);
}

8.2输入输出重载(operator>> and operator<<)

这里的输入和输出为什么重载成全局函数请参考C++类和对象(5)--日期类的实现中友元声明中的注释.

8.2.1输出运算符重载

遍历string对象一个一个输出即可.

ostream& operator<<(ostream& _cout, const string& s)
{
for (auto ch : s)
{
_cout << ch;
}

return _cout;
}

8.2.2输入运算符重载

这里首先先清除s中原有的数据,然后在栈里面开一个256大小的buff(为了减少扩容的次数).这里用get()函数一个一个读取输入的字符,如果用输入运算符的话会忽略输入的空格和换行符.当一个buff满了之后拷贝到s中,跳出循环后如果buff中还有遗留的数据,则全部拷贝到s中.

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

const int N = 256;
char buff[N];
int i = 0;

char ch;
//in >> ch; 默认会忽略空格和换行符
ch = _cin.get();
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;

i = 0;
}
//in >> ch;
ch = _cin.get();
}

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

return _cin;
}

9.参考代码

string实现在XiaoC这个命名空间中,上述的代码没有做测试,下面给出测试代码,有兴趣可以自行对接口进行测试.

9.1string.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
#include <string>
using namespace std;

namespace XiaoC
{
class string
{
//friend ostream& operator<<(ostream& _cout, const XiaoC::string& s);
//friend istream& operator>>(istream& _cin, XiaoC::string& s);
public:
默认构造函数
//string()
////直接给空指针在使用.c_str()时进行打印对空指针进行了解引用
//:_str(new char[1] {'\0'})
////:_str(nullptr)
//,_size(0)
//,_capacity(0)
//{}
//
带参的构造
//string(const char* str)
//{
//_size = strlen(str);
////_capacity不包含\0
//_capacity = _size;
////开空间的时候多开一个用于存储\0
//_str = new char[_capacity + 1];
//strcpy(_str, str);
//}

//将上述两个构造函数合并成一个全缺省的构造函数
string(const char* str = "")//空的常量字符串默认包含一个\0
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1];
strcpy(_str, str);//strcpy先拷贝再判断，会拷贝\0
}


//拷贝构造
//传统写法
//string(const string& s)
//{
//_str = new char[s._capacity + 1];
//strcpy(_str, s._str);
//_size = s._size;
//_capacity = s._capacity;
//}

//现代写法
string(const string& s)
{
string tmp(s._str);
swap(tmp);
}

//赋值重载
//写法1
//string& operator=(const string& s)
//{
//if (this != &s)
//{
//delete[] _str;
//_str = new char[s._capacity + 1];
//strcpy(_str, s._str);
//_size = s._size;
//_capacity = s._capacity;
//}
//return *this;
//}

//写法2
//string& operator=(const string& s)
//{
//if (this != &s)
//{
//string tmp(s);
//swap(tmp);
//}
//return *this;
//}

//写法3
string& operator=(string tmp)
{
swap(tmp);//这里虽然tmp被交换了，但是形参的改变不影响实参
return *this;
}

~string()
{
if (_str)
{
delete[] _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
}

// iterator
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}

const_iterator begin() const
{
return _str;
}

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

// modify
void push_back(char c);
void append(const char* str);
string& operator+=(char c);
string& operator+=(const char* str);

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

//返回string中的指向字符串的指针
const char* c_str() const
{
return _str;
}

// capacity
size_t size() const
{
return _size;
}

size_t capacity() const
{
return _capacity;
}

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

void reserve(size_t n);

// access
char& operator[](size_t index)
{
assert(index < _size);

return _str[index];
}
const char& operator[](size_t index)const
{
assert(index < _size);

return _str[index];
}

// 返回c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const;

// 返回子串s在string中第一次出现的位置
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) const;

private:
char* _str = nullptr;
size_t _capacity = 0;
size_t _size = 0;
//这里可以直接给默认值，相当于定义,因为有const,只有整型可以
//static const size_t npos = -1;
static const size_t npos;
};

//relational operators
bool operator<(const string& s1, const string& s2);
bool operator==(const string s1, const string& s2);
bool operator<=(const string s1, const string& s2);
bool operator>(const string s1, const string& s2);
bool operator>=(const string s1, const string& s2);
bool operator!=(const string s1, const string& s2);

ostream& operator<<(ostream& _cout, const string& s);
istream& operator>>(istream& _cin, string& s);

}

9.2string.cpp

#include "string.h"
namespace XiaoC
{
const size_t string::npos = -1;

void string::push_back(char c)
{
//扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}

_str[_size] = c;
++_size;
_str[_size] = '\0';
}

void string::append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
//大于2倍，需要多少开多少，小于2倍开2倍
reserve((_size + len) > (2 * _capacity) ? (_size + len) : (2 * _capacity));
}

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

string& string::operator+=(char c)
{
push_back(c);
return *this;
}
string& string::operator+=(const char* str)
{
append(str);
return *this;
}

void string::reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}

// 在pos位置上插入字符c/字符串str
void string::insert(size_t pos, char c)
{
assert(pos <= _size);

if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
//这里用size_t类型头插会出错，因为end永远都小于不了0
//size_t end = _size;//从最后一个\0开始往后挪动数据
//用int end在与pos比较时会提升为size_t类型，也会出错
//int end = _size;
//while (end >= (int)pos)
//{
//_str[end + 1] = _str[end];
//end--;
//}

//挪动数据，_size处是\0,从后面的\0开始挪动
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
end--;
}

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

void string::insert(size_t pos, const char* str)
{
assert(pos <= _size);

size_t len = strlen(str);
if (_size + len > _capacity)
{
//大于2倍，需要多少扩多少，小于2倍，扩2倍
reserve((_size + len) > (2 * _capacity) ? (_size + len) : (2 * _capacity));
}

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

for (size_t i = 0; i < len; i++)
{
_str[pos + i] = str[i];
}

_size += len;
}

// 删除pos位置上之后的len个元素
void string::erase(size_t pos, size_t len)
{
assert(pos < _size);

if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
for (size_t i = pos + len; i <= _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
}

// 返回c在string中第一次出现的位置
size_t string::find(char c, size_t pos) const
{
assert(pos < _size);

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

return npos;
}

// 返回子串s在string中第一次出现的位置
size_t string::find(const char* s, size_t pos) const
{
assert(pos < _size);

const char* ptr = strstr(_str + pos, s);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}

//返回子串
string string::substr(size_t pos, size_t len) const
{
assert(pos < _size);

//len大于剩余字符的长度,更新一下len
if (len > _size - pos)
{
len = _size - pos;
}

string sub;
sub.reserve(len);
for (size_t i = 0; i < len; i++)
{
sub += _str[pos + i];
}

return sub;
}

//relational operators
bool operator<(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const string s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator<=(const string s1, const string& s2)
{
return s1 < s2 || s1 == s2;
}
bool operator>(const string s1, const string& s2)
{
return !(s1 <= s2);
}
bool operator>=(const string s1, const string& s2)
{
return !(s1 < s2);
}
bool operator!=(const string s1, const string& s2)
{
return !(s1 == s2);
}

ostream& operator<<(ostream& _cout, const string& s)
{
for (auto ch : s)
{
_cout << ch;
}

return _cout;
}
istream& operator>>(istream& _cin, string& s)
{
s.clear();

const int N = 256;
char buff[N];
int i = 0;

char ch;
//in >> ch; 默认会忽略空格和换行符
ch = _cin.get();
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;

i = 0;
}
//in >> ch;
ch = _cin.get();
}

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

return _cin;
}
}

9.3Test.cpp

#include "string.h"

namespace XiaoC
{
//测试构造函数
void test_string1()
{
string s1;
string s2("hello world");

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

//测试遍历访问
void test_string2()
{
string s1("hello world");
cout << s1.c_str() << endl;

//[] + 下标访问
for (size_t i = 0; i < s1.size(); i++)
{
s1[i] += 2;
}

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

//范围for底层就是替代为迭代器
for (auto e : s1)
{
cout << e << " ";
}
cout << endl;

//通过迭代器遍历访问
string::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}

//测试增删改查
void test_string3()
{
string s1 = "hello world";
s1 += 'x';
s1 += 'c';

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

s1 += " hello XiaoC";
cout << s1.c_str() << endl;

string s2 = "abcd";
cout << s2.c_str() << endl;
s2.insert(0, 'c');
cout << s2.c_str() << endl;

string s3 = "hello world";
cout << s3.c_str() << endl;
s3.insert(0, "xxx");
cout << s3.c_str() << endl;

string s4 = "hello world";
cout << s4.c_str() << endl;
s4.erase(0, 3);
cout << s4.c_str() << endl;

string s("test.cpp.zip");
size_t pos = s.find('.');
string suffix = s.substr(pos);
cout << suffix.c_str() << endl;

//拷贝构造
string copy(s);
cout << copy.c_str() << endl;

//赋值运算符
string s5 = "XiaoC";
s5 = s;
cout << s5.c_str() << endl;
}

//测试比较大小
void test_string4()
{
string s1 = "helloworld";
string s2 = s1;
cout << (s1 == s2) << endl;
cout << (s1 < s2) << endl;
}

//测试输入输出
void test_string5()
{
string s1 = "hello world";
cout << s1 << endl;

string s2;
cin >> s2;
cout << s2 << endl;
}

//测试返回字串
void test_string6()
{
string s1 = "hello world";
string s2;
s2 = s1.substr(6, 5);
cout << s2 << endl;
}
}
int main()
{
//XiaoC::test_string1();
//XiaoC::test_string2();
//XiaoC::test_string3();
//XiaoC::test_string4();
XiaoC::test_string5();
//XiaoC::test_string6();

return 0;
}

原文地址：https://blog.csdn.net/CSQCSQCC/article/details/142360255

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：秋招喜来，分享一份最新的面经
下一篇：质量小议47 - AI写用例

nn.Embedding
在这个代码片段中，类继承了类，并在__init__方法中通过调用来初始化父类。由于没有定义新的方法，默认情况下它会使用的行为来提供返回值。
阅读更多2024-09-23
clinvar数据库variant_summary.txt.gz各列详细介绍
Pathogenic;Pathogenic;used for。
阅读更多2024-09-23
STM32精确控制步进电机
10mm二相四线微型步进电机电机输出是4个引脚，需要自己焊机线，相电阻53欧，步进角度估计18度，丝杆滑块行程32mm，丝杆转一圈铜滑块大约移动行程0.4mm。3. 安全考虑：控制脉冲的最大输出数量，
阅读更多2024-09-23
Go语言中的并发编程
发送通道：可以使用 chan<- 来表示一个只用于发送数据的通道。接收通道：可以使用 <-chan 来表示一个只用于接收数据的通道。import ("fmt"// 定义
阅读更多2024-09-23
从Yargs源码学习中间件的设计
简化复杂逻辑：对于复杂的流程，我们可以拆解成多个简单的步骤，既增加了每个步骤的控制性，又简化了流程操作。例如，在一个请求处理的生命周期中，添加一个新的功能只需要添加一个中间件。我们也可以将中间件的思维
阅读更多2024-09-23
计算机视觉中的几何基元：用Python揭开图像的秘密
嘿，小伙伴们！今天我们要聊的是计算机视觉中的几何基元——那些帮助我们理解和处理图像的神奇工具。无论你是初学者还是资深开发者，这篇文章都将带你深入浅出地了解几何基元，并通过Python代码实战演示。准备
阅读更多2024-09-23
FPGA科学高效的编程方法有哪些？
FPGA的编程方法侧重于并行设计、资源优化和时序管理，科学高效的编程可以大幅提高开发速度和系统性能。在实践中，结合高效工具、模块化设计、并行处理与仿真验证等方法，能帮助开发者应对FPGA开发中的复杂挑
阅读更多2024-09-23
【MySQL】获取最近7天和最近14天的订单数量，使用MySQL详细写出，使用不同的方法
要获取最近7天和最近14天的订单数量，我们可以使用不同的方法来优化查询性能。
阅读更多2024-09-23
论文阅读：A Generalization of Transformer Networks to Graphs
作者提出了一种适用于任何图的GraphTransformer。这种结构不能很好利用图的连通归纳偏置（graph connectivity inductive bias）当图的拓扑结构很重要且尚未编码到
阅读更多2024-09-23
啥？Bing搜索古早BUG至今未改？
首先，大家先看下面的一个数学公式。Γ(z)=∫0∞tz−1e−tdt . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞tz−1e−tdt
阅读更多2024-09-23