c++基础35字符串

字符串

  • 定义字符串
  • 初始化字符串
    • 使用 `std::string` 类
    • 使用 C风格字符数组
    • 使用 `std::string_view`（C++17及以后）
  • 字符串的操作
    • 1. `assign()`
    • 2. `operator=()`
    • 3. `push_back()`
    • 4. `append()`
    • 5. `insert()`
    • 6. `erase()`
    • 7. `clear()`
    • 8. `resize()`
    • 9. `replace()`
    • 10. `pop_back()`
    • 示例代码
    • substr()
    • front()
    • back()
  • 遍历字符串
  • 字符元素重赋值
    • 使用 `std::string` 类
    • 使用 `std::string` 的 `at` 方法
    • 使用 C风格字符数组
    • 注意事项
  • string成员函数
    • 1. `size()` 和 `length()`
    • 2. `empty()`
    • 3. `clear()`
    • 4. `resize()`
  • string查找
    • 1. `find()`
    • 2. `find_first_of()`
    • 3. `find_first_not_of()`
    • 4. `find_last_of()`
    • 5. `find_last_not_of()`
    • 2. `rfind()`
  • 字符串的比较
    • 字典顺序（Lexicographical Order）
    • 字符串比较的方法
  • 字符输入getline
    • 函数原型
    • 使用 `getline` 从 `std::cin` 读取
    • 使用自定义分隔符
    • 注意事项
  • string转c风格字符串
    • 函数原型
    • 使用 `c_str()`
    • 注意事项
  • 字符串与数值的转换
    • 从字符串转换为数值
    • 从数值转换为字符串
  • T245280
    • 自动修正
    • 代码
  • T145188
    • 统计数字字符个数
    • 代码

定义字符串

  1. 使用std::string类：

    #include <string>int main() {std::string str1 = "Hello, World!"; // 直接使用字符串字面量初始化std::string str2 = std::string("Another string"); // 使用std::string构造函数std::string str3; // 空字符串str3 = "Yet another string"; // 赋值操作return 0;
}

  2. 使用C风格字符数组：

    #include <iostream>int main() {char str[] = "Hello, World!"; // 定义并初始化C风格字符串char anotherStr[] = {'A', 'n', 'o', 't', 'h', 'e', 'r', '\0'}; // 手动定义并初始化C风格字符串return 0;
}

  3. 使用std::string_view（C++17及以后）：

    #include <string_view>int main() {std::string str = "Hello, World!";std::string_view view(str); // 非拥有的字符串视图std::string_view literal = "Literal"; // 直接从字符串字面量构造return 0;
}

初始化字符串

使用 std::string 类

  1. 直接初始化：

    std::string str = "Hello, World!"; // 使用字符串字面量直接初始化

  2. 使用构造函数：

    std::string str("Hello, World!"); // 使用构造函数和字符串字面量
std::string str("Hello", 5); // 使用构造函数、字符串字面量和长度
// 从cstr("Hello, World!")中的位置5开始，提取长度为6的子字符串std::string substr("Hello, World!", 5, 6);

  3. 使用字符数组：

    char charArray[] = "Hello, World!";
std::string str(charArray); // 从C风格字符串初始化

  4. 使用字符初始化：

    std::string str(10, 'a'); // 创建一个包含10个'a'字符的字符串

  5. 使用迭代器：

    int numbers[] = {1, 2, 3, 4, 5};
std::string str(std::begin(numbers), std::end(numbers));
// str 将包含 "12345"

  6. 使用 std::initializer_list：

    std::string str = {'H', 'e', 'l', 'l', 'o'}; // 使用初始化列表

  7. 使用 std::vector<char> 或其他容器：

    std::vector<char> vec = {'H', 'e', 'l', 'l', 'o'};
std::string str(vec.begin(), vec.end());

使用 C风格字符数组

  1. 直接声明和初始化：

    char str[] = "Hello, World!"; // 声明并初始化C风格字符串

  2. 使用字符赋值：

    char str[20];
strcpy(str, "Hello, World!"); // 使用strcpy函数复制字符串

  3. 逐个字符赋值：

    char str[20];
int i = 0;
const char* hello = "Hello, World!";
while (hello[i] != '\0') {str[i] = hello[i];++i;
}
str[i] = '\0'; // 确保字符串以空字符结尾

使用 std::string_view（C++17及以后）

  1. 直接初始化：

    std::string str = "Hello, World!";
std::string_view view(str); // 从std::string初始化std::string_view

  2. 使用字符串字面量：

    std::string_view view = "Hello, World!"; // 直接从字符串字面量初始化

字符串的操作

1. assign()

用一个新的值来替换字符串的内容。

std::string str = "Hello";
str.assign("World"); // str now contains "World"

2. operator=()

使用赋值运算符来替换字符串的内容。

std::string str = "Hello";
str = "World"; // str now contains "World"

3. push_back()

在字符串的末尾添加一个字符。

std::string str = "Hello";
str.push_back('!'); // str now contains "Hello!"

4. append()

在字符串的末尾添加一个字符串或字符。

std::string str = "Hello";
str.append(" World"); // str now contains "Hello World"

5. insert()

在指定位置插入一个字符串或字符。

std::string str = "Hello";
str.insert(5, " World"); // str now contains "Hello World"

6. erase()

删除字符串中的一部分。

std::string str = "Hello World";
str.erase(6, 5); // str now contains "Hello "

7. clear()

清空字符串，使其变为一个空字符串。

std::string str = "Hello";
str.clear(); // str now contains ""

8. resize()

改变字符串的长度，如果需要，可以用指定的字符填充。

std::string str = "Hello";
str.resize(10, '!'); // str now contains "Hello!!!!!"

9. replace()

替换字符串中的部分内容。

std::string str = "Hello World";
str.replace(6, 5, "there"); // str now contains "Hello there"

10. pop_back()

移除字符串的最后一个字符。

std::string str = "Hello";
str.pop_back(); // str now contains "Hell"

示例代码

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";// 使用assign修改字符串str.assign("Goodbye, World!");std::cout << str << std::endl; // 输出: Goodbye, World!// 使用append添加字符串str.append(" Have a nice day!");std::cout << str << std::endl; // 输出: Goodbye, World! Have a nice day!// 使用insert插入字符串str.insert(7, ", Cruel ");std::cout << str << std::endl; // 输出: Goodbye, Cruel World! Have a nice day!// 使用erase删除字符串的一部分str.erase(14, 6);std::cout << str << std::endl; // 输出: Goodbye, Cruel World! a nice day!// 使用clear清空字符串str.clear();std::cout << str << std::endl; // 输出: (空)return 0;
}

在C++的std::string类中，substr、front和back是三个用于访问和操作字符串内容的成员函数。

substr()

substr()函数用于获取字符串的一个子串（substring）。你可以指定子串的起始位置和长度。

std::string substr(size_type pos = 0, size_type len = npos) const;
  • pos：子串的起始位置（默认为0，即字符串的开始）。
  • len：子串的长度（默认为std::string::npos，即直到字符串的末尾）。

示例代码：

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";// 获取从位置7开始的子串，长度为5std::string sub = str.substr(7, 5);std::cout << sub << std::endl; // 输出: World// 获取从位置0开始直到字符串末尾的子串std::string sub2 = str.substr();std::cout << sub2 << std::endl; // 输出: Hello, World!return 0;
}

front()

front()函数用于获取字符串的第一个字符。这个函数是C++11标准中引入的，用于提供对字符串第一个元素的访问。

char& front();
const char& front() const;
  • 返回一个引用，允许修改字符串的第一个字符（非const版本）。
  • 返回一个常量引用，不允许修改字符串的第一个字符（const版本）。

示例代码：

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";// 获取并打印字符串的第一个字符std::cout << "The first character is: " << str.front() << std::endl; // 输出: H// 修改字符串的第一个字符str.front() = 'h';std::cout << "The modified string is: " << str << std::endl; // 输出: hello, World!return 0;
}

back()

back()函数用于获取字符串的最后一个字符。这个函数也是C++11标准中引入的，用于提供对字符串最后一个元素的访问。

char& back();
const char& back() const;
  • 返回一个引用，允许修改字符串的最后一个字符（非const版本）。
  • 返回一个常量引用，不允许修改字符串的最后一个字符（const版本）。

示例代码：

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";// 获取并打印字符串的最后一个字符std::cout << "The last character is: " << str.back() << std::endl; // 输出: !// 修改字符串的最后一个字符str.back() = '?';std::cout << "The modified string is: " << str << std::endl; // 输出: Hello, World?return 0;
}

遍历字符串

遍历字符串意味着逐个访问字符串中的每个字符，直到字符串结束。

  1. 使用索引：

    #include <iostream>
#include <string>int main() {std::string str = "Hello, World!";for (size_t i = 0; i < str.length(); ++i) {std::cout << str[i];}std::cout << std::endl;return 0;
}

  2. 使用C++11范围基于for循环：

    #include <iostream>
#include <string>int main() {std::string str = "Hello, World!";for (char c : str) {std::cout << c;}std::cout << std::endl;return 0;
}

  3. 使用迭代器：

    #include <iostream>
#include <string>int main() {std::string str = "Hello, World!";for (std::string::iterator it = str.begin(); it != str.end(); ++it) {std::cout << *it;}std::cout << std::endl;return 0;
}

  4. 使用C风格字符数组的指针遍历：

    #include <iostream>int main() {char str[] = "Hello, World!";for (char *p = str; *p != '\0'; ++p) {std::cout << *p;}std::cout << std::endl;return 0;
}

字符元素重赋值

在C++中，字符串中的元素重赋值指的是修改字符串中的某个特定位置的字符。对于std::string类，你可以通过索引来访问和修改字符串中的字符。对于C风格的字符数组，你也可以通过索引来修改字符，但需要确保不要越界。

使用 std::string 类

对于std::string对象，你可以直接通过下标操作符[]来访问和修改字符串中的元素。

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";std::cout << "Initial string: " << str << std::endl;// 修改字符串中的元素str[0] = 'h'; // 将第一个字符'H'修改为小写的'h'str[7] = 'w'; // 将第七个字符'W'修改为小写的'w'std::cout << "Modified string: " << str << std::endl;return 0;
}

使用 std::string 的 at 方法

std::string 类还提供了at方法，它允许你访问字符串中的元素，并在越界时抛出一个std::out_of_range异常。

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";std::cout << "Initial string: " << str << std::endl;// 使用at方法修改字符串中的元素str.at(0) = 'h'; // 将第一个字符'H'修改为小写的'h'str.at(7) = 'w'; // 将第七个字符'W'修改为小写的'w'std::cout << "Modified string: " << str << std::endl;return 0;
}

使用 C风格字符数组

对于C风格的字符数组，你可以通过下标操作符[]来访问和修改数组中的元素。

#include <iostream>int main() {char str[] = "Hello, World!";std::cout << "Initial string: " << str << std::endl;// 修改字符串中的元素str[0] = 'h'; // 将第一个字符'H'修改为小写的'h'str[7] = 'w'; // 将第七个字符'W'修改为小写的'w'std::cout << "Modified string: " << str << std::endl;return 0;
}

注意事项

  • 当使用std::string的[]操作符时，如果索引超出了字符串的当前长度，std::string会自动扩展字符串，并用空字符填充新分配的空间，直到索引位置。
  • 当使用C风格字符数组时，你需要确保不会越界，因为这可能导致未定义行为，包括程序崩溃。

string成员函数

1. size() 和 length()

size() 和 length() 函数都返回字符串中的字符数。这两个函数在 std::string 类中是等价的，都返回字符串的长度。

#include <iostream>
#include <string>int main() {std::string str = "Hello";std::cout << "Size: " << str.size() << std::endl;  // 输出: Size: 5std::cout << "Length: " << str.length() << std::endl;  // 输出: Length: 5return 0;
}

2. empty()

empty() 函数检查字符串是否为空。如果字符串为空（即没有字符），则返回 true；否则返回 false。

#include <iostream>
#include <string>int main() {std::string str;str.empty() ? std::cout << "String is empty." << std::endl : std::cout << "String is not empty." << std::endl;// 输出: String is empty.std::string str2 = "Hello";str2.empty() ? std::cout << "String is empty." << std::endl : std::cout << "String is not empty." << std::endl;// 输出: String is not empty.return 0;
}

3. clear()

clear() 函数用于清空字符串的内容，使其变为一个空字符串。

#include <iostream>
#include <string>int main() {std::string str = "Hello";std::cout << "Before clear: " << str << std::endl;  // 输出: Before clear: Hellostr.clear();std::cout << "After clear: " << str << std::endl;  // 输出: After clear: (空)return 0;
}

4. resize()

resize() 函数用于改变字符串的长度。如果新长度大于当前长度，resize() 会在字符串末尾添加指定数量的字符。默认情况下，添加的是空字符（'\0'），但你也可以指定其他字符。

#include <iostream>
#include <string>int main() {std::string str = "Hello";std::cout << "Original string: " << str << std::endl;  // 输出: Original string: Hello// 将字符串长度增加到10，添加空字符str.resize(10);//resize(10,'A');用A填空增加的字符std::cout << "Resized string (with '\\0'): " << str << std::endl;  // 输出: Resized string (with '\0'): Hello\0\0\0\0// 将字符串长度减少到3str.resize(3);std::cout << "Resized string: " << str << std::endl;  // 输出: Resized string: Helreturn 0;
}

string查找

在C++中，std::string 类提供了多个成员函数来查找字符串中的子串(中的字符)或单个字符。

find(字符或字符串，位置）//位置可以省略，表示从首位开始查找，其它的rfind等函数用法类似

1. find()

find() 函数用于查找子串或字符在字符串中第一次出现的位置。如果找到，它返回子串或字符的索引；如果没有找到，它返回 std::string::npos。

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";std::size_t pos = str.find("World");if (pos != std::string::npos) {std::cout << "Found 'World' at position: " << pos << std::endl;} else {std::cout << "'World' not found." << std::endl;}char ch = 'l';pos = str.find(ch);if (pos != std::string::npos) {std::cout << "Found '" << ch << "' at position: " << pos << std::endl;} else {std::cout << "'" << ch << "' not found." << std::endl;}return 0;
}

2. find_first_of()

find_first_of() 函数用于查找任何在指定字符串中出现的字符或字符串在字符串中第一次出现的位置。

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";std::string chars = "Wrd";std::size_t pos = str.find_first_of(chars);if (pos != std::string::npos) {std::cout << "Found one of 'Wrd' at position: " << pos << std::endl;} else {std::cout << "None of 'Wrd' found." << std::endl;}return 0;
}

3. find_first_not_of()

find_first_not_of() 函数用于查找不在指定字符串中的字符或字符串第一次出现的位置。

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";std::string chars = "Hlo";std::size_t pos = str.find_first_not_of(chars);if (pos != std::string::npos) {std::cout << "Found a character not in 'Hlo' at position: " << pos << std::endl;} else {std::cout << "All characters are in 'Hlo'." << std::endl;}return 0;
}

4. find_last_of()

find_last_of() 函数用于查找任何在指定字符串中出现的字符在字符串中最后一次出现的位置。

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";std::string chars = "Wrd";std::size_t pos = str.find_last_of(chars);if (pos != std::string::npos) {std::cout << "Found one of 'Wrd' at position: " << pos << std::endl;} else {std::cout << "None of 'Wrd' found." << std::endl;}return 0;
}

5. find_last_not_of()

find_last_not_of() 函数用于查找不在指定字符串中的字符最后一次出现的位置。

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";std::string chars = "Hlo";std::size_t pos = str.find_last_not_of(chars);if (pos != std::string::npos) {std::cout << "Found a character not in 'Hlo' at position: " << pos << std::endl;} else {std::cout << "All characters are in 'Hlo'." << std::endl;}return 0;
}

2. rfind()

rfind() 函数用于从字符串的指定位置开始向后搜索子串或字符，并返回子串或字符最后一次出现的索引。如果未找到，则返回std::string::npos。

std::size_t rfind(const std::string& str, std::size_t pos = std::string::npos) const;
std::size_t rfind(const char* s, std::size_t pos = std::string::npos) const;
std::size_t rfind(char c, std::size_t pos = std::string::npos) const;
  • str：要查找的子串。
  • s：C风格字符串，要查找的子串。
  • c：要查找的字符。
  • pos：开始搜索的位置，默认为std::string::npos，即字符串末尾。

示例：

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";std::size_t pos = str.rfind("o");if (pos != std::string::npos) {std::cout << "Found 'o' at position: " << pos << std::endl;} else {std::cout << "'o' not found." << std::endl;}return 0;
}

字符串的比较

在C++中，字符串的大小比较和顺序比较实际上是同一回事，因为字符串的比较是基于字典顺序（lexicographical order）进行的。这意味着字符串是按字符从左到右进行比较的，就像在字典中查找单词一样。

字典顺序（Lexicographical Order）

字典顺序是比较字符串的标准方法，它逐个字符比较两个字符串：

  1. 字符比较：从两个字符串的开始位置比较对应位置的字符。如果一个字符串的字符大于另一个字符串的字符，则该字符串被认为是“更大”的。如果字符相等，则比较下一个字符，依此类推。
  2. 长度比较：如果两个字符串的相应位置字符都相等，并且一个字符串是另一个字符串的前缀（即一个字符串是另一个字符串的开始部分），那么更长的字符串被认为是“更大”的。
  3. 完全相等：如果两个字符串在所有字符上都相等，那么它们被认为是相等的。

字符串比较的方法

在C++中，你可以使用以下方法来比较字符串的大小：

  1. 使用比较运算符（==, !=, <, >, <=, >=）：

    std::string str1 = "apple";
std::string str2 = "banana";
if (str1 < str2) {std::cout << "str1 is less than str2" << std::endl;
} else {std::cout << "str1 is greater than or equal to str2" << std::endl;
}

  2. 使用std::string类的compare方法：

    std::string str1 = "apple";
std::string str2 = "banana";
if (str1.compare(str2) < 0) {std::cout << "str1 is less than str2" << std::endl;
} else {std::cout << "str1 is greater than or equal to str2" << std::endl;
}

  3. 使用strncmp函数（对于C风格字符串）：

    const char* str1 = "apple";
const char* str2 = "banana";
if (strncmp(str1, str2, strlen(str1)) < 0) {std::cout << "str1 is less than str2" << std::endl;
} else {std::cout << "str1 is greater than or equal to str2" << std::endl;
}

字符输入getline

在C++中，getline 是一个非常有用的函数，用于从输入流中读取一行字符串。这个函数可以读取直到换行符（'\n'）为止的所有字符，并将它们存储在一个字符串中。getline 函数通常与 std::cin（标准输入流）一起使用，但也可以从文件流或其他输入流中读取。

函数原型

getline 函数的原型如下：

std::istream& getline(std::istream& is, std::string& str);
std::istream& getline(std::istream& is, std::string& str, char delim);
  • is：输入流的引用，可以是 std::cin 或其他输入流。
  • str：用于存储读取的字符串。
  • delim：分隔符，默认为换行符 '\n'。读取将停止在遇到这个字符之前。

使用 getline 从 std::cin 读取

#include <iostream>
#include <string>int main() {std::string line;std::cout << "Enter a line of text: ";std::getline(std::cin, line);std::cout << "You entered: " << line << std::endl;return 0;
}

在这个例子中，程序提示用户输入一行文本，然后使用 getline 读取这行文本，并将其存储在 line 字符串中。

使用自定义分隔符

你也可以指定一个自定义的分隔符来读取字符串：

#include <iostream>
#include <string>int main() {std::string line;std::cout << "Enter a line of text separated by ';': ";std::getline(std::cin, line, ';');std::cout << "You entered: " << line << std::endl;return 0;
}

在这个例子中，getline 将读取直到遇到分号（';'）为止的所有字符。

注意事项

  • getline 会将换行符（或指定的分隔符）从输入流中消耗掉，但不包括在结果字符串中。
  • 如果输入流到达文件末尾（EOF），getline 将不会读取任何内容，并且返回 false。
  • 如果在读取过程中发生错误，getline 也会返回 false。
  • cin不会消耗换行符，与getline连用时，注意bug
#include <iostream>
#include<string>
using namespace std;
int main() {string s1,s2;//输入 空空空asdfd换行123换行 cin>>s1;//cin读asdfd到s1，遇到换行符就完成使命。换行符留在缓存，getline读到换行符就显示输出，结束程序 getline(cin,s2);//123没有读，程序就结束了 cout<<s1.size()<<" "<<s2.size()<<endl;return 0;
}

string转c风格字符串

在C++中，c_str() 是 std::string 类的一个成员函数，它返回一个指向以空字符（'\0'）结尾的字符数组的指针。这个字符数组是C风格的字符串，可以用来与接受C风格字符串参数的函数进行接口。

函数原型

c_str() 函数的原型如下：

const char* c_str() const;

这个函数返回一个指向常量字符数组的指针，因此返回的字符串不应该被修改。

使用 c_str()

#include <iostream>
#include <string>int main() {std::string str = "Hello, World!";const char* cstr = str.c_str();// 使用C风格字符串std::cout << "C-style string: " << cstr << std::endl;// 传递给接受C风格字符串的函数std::cout << "C-style string length: " << strlen(cstr) << std::endl;return 0;
}

在这个例子中，c_str() 被用来获取 std::string 对象的C风格字符串表示，并将其存储在 cstr 指针中。然后，这个指针被用来输出字符串，并传递给 strlen 函数来计算字符串的长度。

注意事项

  • c_str() 返回的指针只在原始 std::string 对象的生命周期内有效。如果 std::string 对象被修改或销毁，那么返回的指针可能变得无效。
  • c_str() 返回的是一个指向常量数据的指针，因此你不应该尝试修改通过 c_str() 获取的字符串。
  • 如果你需要修改字符串，应该直接使用 std::string 对象，或者使用 data() 函数，它返回一个非常量的指针，允许修改字符串。

字符串与数值的转换

在C++中，将字符串和数值之间进行转换是一项常见的任务。以下是一些用于执行这些转换的标准库函数和方法：

从字符串转换为数值

  1. std::stoi：将字符串转换为int。

    std::string str = "123";
int num = std::stoi(str);

  2. std::stol：将字符串转换为long。

    std::string str = "123";
long num = std::stol(str);

  3. std::stoll：将字符串转换为long long。

    std::string str = "123";
long long num = std::stoll(str);

  4. std::stoul：将字符串转换为unsigned long。

    std::string str = "123";
unsigned long num = std::stoul(str);

  5. std::stoull：将字符串转换为unsigned long long。

    std::string str = "123";
unsigned long long num = std::stoull(str);

  6. std::stof：将字符串转换为float。

    std::string str = "123.45";
float num = std::stof(str);

  7. std::stod：将字符串转换为double。

    std::string str = "123.45";
double num = std::stod(str);

  8. std::stold：将字符串转换为long double。

    std::string str = "123.45";
long double num = std::stold(str);

从数值转换为字符串

  1. std::to_string：将数值转换为字符串。

    int num = 123;
std::string str = std::to_string(num);

  2. std::stringstream：使用流操作将数值转换为字符串。

    #include <sstream>
int num = 123;
std::stringstream ss;
ss << num;
std::string str = ss.str();

T245280

自动修正

  • 题目描述

大家都知道一些办公软件有自动将字母转换为大写的功能。输入一个长度不超过 100 且不包括空格的字符串。要求将该字符串中的所有小写字母变成大写字母并输出。

  • 样例输入
Luogu4!
  • 样例输出
LUOGU4!

代码

#include <iostream>
#include<string>
using namespace std;
int main() {string s;cin>>s;for(char c:s){cout<<(char) toupper(c);}return 0;
}

T145188

统计数字字符个数

  • 题目描述

输入一行字符，统计出其中数字字符的个数。

  • 输入格式

一行字符串，总长度不超过 255 。

  • 输出格式

输出为 1 行，输出字符串里面数字字符的个数。

  • 样例输入
Peking University is set up at 1898.
  • 样例输出
4

代码

#include <iostream>
#include<string>
using namespace std;
int main() {string s1;int c=0; getline(cin,s1);for(auto i:s1){if(isdigit(i)){c++;}}cout<<c;return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/17875.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

c++入门-＞类的定义以及this详细解析

c++入门-＞类的定义以及this详细解析

1.对象的定义 可以在内部定义变量还有函数&#xff0c;而其中的public是声明这里面的东西是共有的&#xff0c;可以调用也可以修改&#xff0c;但是private则是声明这里面的东西是私有的不可以被改变的&#xff0c;但是在类里面共有的是可以使用私有的。 在对象中默认都是私有…
阅读更多...
SAP- 不写代码创建报表

SAP- 不写代码创建报表

创建报表 点击报保存&#xff0c;表Z0708创建完成 关联三张数据库底表 点击返回 点击报保存&#xff0c;表Z0708创建完成 创建报表
阅读更多...
从PE结构到LoadLibrary

从PE结构到LoadLibrary

从PE结构到LoadLibrary PE是Windows平台主流可执行文件格式,.exe , .dll, .sys, .com文件都是PE格式 32位的PE文件称为PE32&#xff0c;64位的称为PE32&#xff0c;PE文件格式在winnt.h头中有着详细的定义&#xff0c;PE文件头包含了一个程序在运行时需要的所有信息&#xff…
阅读更多...
聚类分析 | MSADBO优化Spectral谱聚类优化算法

聚类分析 | MSADBO优化Spectral谱聚类优化算法

目录 效果一览基本介绍程序设计参考资料 效果一览 基本介绍 基于改进正弦算法引导的蜣螂优化算法(MSADBO)优化Spectral谱聚类&#xff0c;matlab代码&#xff0c;直接运行! 创新独家&#xff0c;先用先发&#xff0c;注释清晰&#xff0c;送MSADBO参考文献!优化参数 优化后的带…
阅读更多...
【C++】构造与析构函数

【C++】构造与析构函数

目录&#xff1a; 一、 This指针　 &#xff08;一&#xff09;使用方法&#xff1a; 二、类的默认成员函数 三、构造函数　 &#xff08;一&#xff09;构造函数的特点 四、析构函数 &#xff08;一&#xff09;析构函数的特点 正文 一、 This指针 在c语言中我们调用函…
阅读更多...
2021TCSVT，VDM-DA：面向无源数据域自适应的虚拟域建模

2021TCSVT，VDM-DA：面向无源数据域自适应的虚拟域建模

原文标题&#xff1a;VDM-DA: Virtual Domain Modeling for Source Data-free Domain Adaptation 中文标题&#xff1a;VDM-DA&#xff1a;面向无源数据域自适应的虚拟域建模 1、Abstract 领域适应旨在利用标签丰富的领域&#xff08;源领域&#xff09;来帮助标签稀缺领域&…
阅读更多...
MySQL数据库1——数据库概论

MySQL数据库1——数据库概论

一.数据库概论 1.数据库 数据库&#xff08;DataBase&#xff0c;DB&#xff09;&#xff1a;是长期存储在计算机内、有组织的、统一管理的相关数据的集合。简单来说&#xff0c;它就是一个存储各种数据的仓库&#xff0c;且存储过程不是随便而是有组织的。 数据库管理系统&am…
阅读更多...
英伟达Tensor Core技术架构原理分析

英伟达Tensor Core技术架构原理分析

英伟达Tensor Core架构技术原理 英伟达的Tensor Core架构是一种专为加速人工智能、深度学习、高性能计算(HPC)等领域中的矩阵运算和张量运算而设计的硬件单元。自首次在Volta架构中引入以来&#xff0c;Tensor Cores已成为NVIDIA高端GPU的核心特性&#xff0c;并在后续的Turing…
阅读更多...
Linux基础5-进程控制1(fork创建子进程，写时拷贝，进程退出)

Linux基础5-进程控制1(fork创建子进程，写时拷贝，进程退出)

上篇文章&#xff1a;Linux基础4-进程5&#xff08;程序地址空间详解&#xff09;-CSDN博客 本篇重点&#xff1a;fork&#xff0c;写实拷贝&#xff0c;进程退出 目录 一. fork创建子进程 1.1 fork用法 1.2 fork返回值有两个的理解 二. 进程退出码 2.1 进程退出码 2.2 进…
阅读更多...
用python中的tkinter包实现进度条

用python中的tkinter包实现进度条

python中的tkinter包是一种常见的设计程序的GUI界面用的包。本文主要介绍这里面的一个组件&#xff1a;进度条&#xff08;Progressbar&#xff09;。Tkinter Progressbar里面对进度条组件已经做了一定的介绍&#xff0c;但比较抽象。本文以另一种方式介绍这个组件及其常用用法…
阅读更多...
20.使用标准差剔除异常值

20.使用标准差剔除异常值

标准差剔除异常值 1. 方法2. 示例代码2.1 数据读取与清洗2.2 分段读取数据并绘图2.3 解释2.4 outliers2.5 结果展示 我有个记录数据采集后格式是step_rewards.txt 的文档&#xff0c;里面只有一列数据&#xff0c;10*10000行数据&#xff0c;没有表头&#xff0c;分别代表奖励数…
阅读更多...
中科蓝讯修改蓝牙名字：【图文讲解】

中科蓝讯修改蓝牙名字：【图文讲解】

本文以市面上一款公板公模的畅销产品为例。K12蓝牙音响。 音响用的芯片是&#xff1a;AB5768E MIC用的芯片是&#xff1a;AB5769A 硬件框架图如下&#xff1a; 芯片修改名字&#xff0c;通过下载工具中的配置进行修改。选择蓝牙配置&#xff0c;然后会出现蓝牙名字&#xff…
阅读更多...
旅行包发霉怎么处理 除霉及防霉解决方法

旅行包发霉怎么处理 除霉及防霉解决方法

近些年听到很多箱包工厂的心声&#xff0c;为什么箱包旅行包每年都会出现长霉请况呢&#xff1f;长霉了&#xff0c;也就是长毛了&#xff0c;长出那些病菌、真菌、细菌等微生物。经ihaoer防霉人士介绍旅行包长霉处理方法如下&#xff1a; 旅行包长霉的因素 一、旅行包储存在阴…
阅读更多...
14、交互补充

14、交互补充

1、元素的三大系列 1.1、offset系列 1.1.1、offset初相识 使用offset系列相关属性可以动态的得到该元素的位置&#xff08;偏移&#xff09;、大小等 获得元素距离带有定位祖先元素的位置获得元素自身的大小&#xff08;宽度高度&#xff09;注意&#xff1a;返回的数值都不…
阅读更多...
【IEEE出版、八大高校联合举办、稳定EI检索】第四届人工智能与智能制造国际研讨会（AIIM 2024，12月20-22日）

【IEEE出版、八大高校联合举办、稳定EI检索】第四届人工智能与智能制造国际研讨会（AIIM 2024，12月20-22日）

第四届人工智能与智能制造国际研讨会&#xff08;AIIM 2024&#xff09; The 4th International Symposium on Artificial Intelligence and Intelligent Manufacturing 2024年12月20-22日 中国成都 重要信息 大会官网&#xff1a;www.isaiim.com 大会时间&#xff1a;202…
阅读更多...
朴素贝叶斯算法探讨与实践

朴素贝叶斯算法探讨与实践

引言 和撰写博文[1]的缘由一样&#xff0c;本文是想要在所创设的专栏[2]里把所谓的十大机器学习算法[3]全部过一遍。 朴素贝叶斯算法是传统机器学习里的一种可以被用来进行分类的算法&#xff0c;本文将对其原理进行说明&#xff0c;并基于原理给出一个基于该算法的分类实践。…
阅读更多...
《数据在内存中的存储》

《数据在内存中的存储》

内存函数 1. 整数在内存中的存储 &#xff08;1&#xff09;旧识回顾&#xff1a; 之前在学到操作符的时候&#xff0c;我们就学过了下面的内容&#xff1a; 整数的二进制的表示方式有三种&#xff0c;原码、反码、补码 有符号的整数&#xff0c;三种表示方式均有符号位和数…
阅读更多...
【路径规划】粒子群算法、遗传算法、差分进化算法、灰狼优化算法、麻雀优化算法(PSO、GA、DE、GWO、SSA)路径规划

【路径规划】粒子群算法、遗传算法、差分进化算法、灰狼优化算法、麻雀优化算法(PSO、GA、DE、GWO、SSA)路径规划

摘要 本文探讨了多种智能优化算法在路径规划中的应用&#xff0c;包括粒子群算法&#xff08;PSO&#xff09;、遗传算法&#xff08;GA&#xff09;、差分进化算法&#xff08;DE&#xff09;、灰狼优化算法&#xff08;GWO&#xff09;和麻雀优化算法&#xff08;SSA&#x…
阅读更多...
CSS基础知识05（弹性盒子、布局详解，动画，3D转换，calc）

CSS基础知识05（弹性盒子、布局详解，动画，3D转换，calc）

目录 0、弹性盒子、布局 0.1.弹性盒子的基本概念 0.2.弹性盒子的主轴和交叉轴 0.3.弹性盒子的属性 flex-direction row row-reverse column column-reverse flex-wrap nowrap wrap wrap-reverse flex-dirction和flex-wrap的组合简写模式 justify-content flex-s…
阅读更多...
如何搭建一台邮箱服务器,配置满分邮箱

如何搭建一台邮箱服务器,配置满分邮箱

如何搭建一台邮箱服务器,配置满分邮箱 搭建一台个人邮箱服务器听上去非常有技术含量&#xff0c;但只要准备工作充分&#xff0c;并且选择合适的软件&#xff0c;配置满分的邮箱&#xff0c;其实并没有想象中那么困难。在这篇文章中&#xff0c;我们将介绍搭建邮箱服务器的 必备…
阅读更多...
最新文章

Copyright @ 2022~2023