C++的std::vector
是一个序列容器,它封装了动态大小数组的行为。
Go的切片(Slice)是动态的,基于数组,但提供了更灵活的接口。
std::vector
std::vector<int> vec = {1, 2, 3};
vec.push_back(4);
slice := []int{1, 2, 3}
slice = append(slice, 4)
std::vector<int> vec = {1, 2, 3};
slice := []int{1, 2, 3}
vec.push_back(4);
slice = append(slice, 4)
int first = vec[0];
first := slice[0]
vec[0] = 10;
slice[0] = 10
vec.pop_back();
或 vec.erase(vec.begin() + index);
slice = slice[:index]
或 slice = slice[index+1:]
size_t size = vec.size();
size := len(slice)
vec.clear();
slice = slice[:0]
for(auto& x : vec) { ... }
range
进行遍历 for _, value := range slice { ... }
C++中的std::string
是一个可变的数据结构,用于处理文本数据。Go中的字符串是不可变的,但Go提供了丰富的字符串处理函数。
std::string str = "Hello, ";
str += " World!";
str := "Hello, "
str += " World!"
std::string str = "Hello, World!";
str := "Hello, World!"
str += " World!";
str += " World!"
char ch = str[0];
ch := str[0]
str[0] = 'h';
size_t length = str.length();
length := len(str)
size_t pos = str.find("World");
pos := strings.Index(str, "World")
str.replace(5, 5, "there");
str = strings.Replace(str, "World", "there", 1)
std::string sub = str.substr(7, 5);
sub := str[7:12]
bool result = (str == "Hello, World!");
result := str == "Hello, World!"
str = str;
std::transform(str.begin(), str.end(), str.begin(), ::tolower);
str = strings.ToLower(str)
str.erase(std::remove_if(str.begin(), str.end(), isspace), str.end());
str = strings.TrimSpace(str)
std::istringstream
tokens := strings.Split(str, " ")
在C++和Go中,映射(Map)是一种将键(Key)映射到值(Value)的数据结构。C++提供了两种类型的映射:std::map
和std::unordered_map
。std::map
是基于红黑树实现的有序映射,而std::unordered_map
是基于哈希表实现的无序映射。Go中的映射(Map)也是基于哈希表实现的,元素无序,但提供了简洁的操作方式。
std::map<int, std::string> map = {{1, "one"}, {2, "two"}};
std::unordered_map<int, std::string> unorderedMap = {{1, "one"}, {2, "two"}};
mapIntStr := map[int]string{1: "one", 2: "two"}
map[3] = "three"; // 对于std::map和std::unordered_map
mapIntStr[3] = "three"
std::string value = map[1]; // 访问存在的键
// 如果键不存在,使用[]运算符会插入一个默认值
std::string defaultValue = map[3]; // 键3不存在,将插入默认值空字符串""
// 使用at()访问不存在的键会抛出异常
try {
std::string atValue = map.at(3); // 将抛出异常
} catch (const std::out_of_range& e) {
std::cerr << e.what() << '\n';
}
value, ok := mapIntStr[1] // 访问存在的键,ok用于判断键是否存在
map[1] = "ONE"; // 修改存在的键
mapIntStr[1] = "ONE"
map.erase(1); // 删除键为1的元素
unorderedMap.erase(1);
delete(mapIntStr, 1)
bool exists = map.count(1) > 0; // std::map和std::unordered_map
_, exists := mapIntStr[1]
for (const auto& pair : map) {
std::cout << pair.second << std::endl;
}
for _, value := range mapIntStr {
fmt.Println(value)
}
size_t size = map.size(); // std::map和std::unordered_map
size := len(mapIntStr)
map.clear(); // std::map和std::unordered_map
mapIntStr = make(map[int]string)
std::map
和std::unordered_map
提供了丰富的成员函数来操作映射。std::map
保持元素的有序性,而std::unordered_map
提供更快的查找速度但元素无序。std::map
和std::unordered_map
会抛出异常。[]
操作符会插入一个具有默认值的新元素,而使用at()
成员函数则会抛出std::out_of_range
异常。ok
标志,而不是抛出异常。在C++中,std::set
和std::unordered_set
提供了有序和无序的集合功能。Go语言没有内置的集合类型,但可以通过映射(Map)来模拟集合的行为,通过将元素作为键,而值可以是布尔类型或其他占位类型。
std::set
和std::unordered_set
std::set<int> set = {1, 2, 3};
std::set<int> set = {1, 2, 3};
set.insert(4);
set.insert(4);
bool exists = set.find(2) != set.end();
bool exists = set.find(2) != set.end();
set.erase(2);
set.erase(2);
bool exists = set.count(2) > 0;
bool exists = set.count(2) > 0;
size_t size = set.size();
size_t size = set.size();
set.clear();
set.clear();
for (int num : set) { ... }
for (int num : set) {
std::cout << num << " ";
}
set := make(map[int]struct{})
set := make(map[int]struct{})
set[1] = struct{}{}
set[2] = struct{}{}
set[3] = struct{}{}
set[key] = struct{}{}
set[4] = struct{}{}
_, exists := set[key]; exists
_, exists := set[2]; exists
delete(set, key)
delete(set, 2)
_, exists := set[key]; exists
_, exists := set[2]; exists
size := len(set)
size := len(set)
set = make(map[int]struct{})
set = make(map[int]struct{})
range
进行遍历 for num := range set {
fmt.Println(num)
}
std::set
和std::unordered_set
提供了丰富的成员函数来操作集合。std::set
保持元素的有序性,而std::unordered_set
提供更快的查找速度但元素无序。std::set
和std::unordered_set
会返回一个迭代器到集合的末尾。ok
标志,而不是返回一个迭代器。C++提供了std::stack
和std::queue
等容器适配器,而Go可以通过切片或通道来模拟这些数据结构。以下是C++和Go中栈和队列操作的详细对比:
std::stack
std::stack<int> stack;
stack.push(1);
int top = stack.top();
stack.pop();
bool empty = stack.empty();
size_t size = stack.size();
stack := []int{}
stack = append(stack, 1)stack = append(stack, value)
stack = append(stack, 1)top := stack[len(stack)-1]
top := stack[len(stack)-1]stack = stack[:len(stack)-1]
stack = stack[:len(stack)-1]empty := len(stack) == 0
empty := len(stack) == 0size := len(stack)
size := len(stack)std::queue
std::queue<int> queue;
queue.push(1);
int front = queue.front();
queue.pop();
bool empty = queue.empty();
size_t size = queue.size();
queue := []int{}
queue = append(queue, 1)queue = append(queue, value)
queue = append(queue, 1)front := queue[0]
front := queue[0]queue = queue[1:]
queue = queue[1:]empty := len(queue) == 0
empty := len(queue) == 0size := len(queue)
size := len(queue)std::deque
std::deque<int> deque;
deque.push_back(1);
deque.push_front(0);
deque.pop_back();
deque.pop_front();
bool empty = deque.empty();
size_t size = deque.size();
deque := []int{}
deque = append(deque, 1) // push backdeque = append(deque, value)
deque = append(deque, 1)deque = deque[:len(deque)-1]
deque = deque[:len(deque)-1]deque = deque[1:]
deque = deque[1:]empty := len(deque) == 0
empty := len(deque) == 0size := len(deque)
size := len(deque)原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。
原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。
如有侵权,请联系 cloudcommunity@tencent.com 删除。