基本数据类型：
在 C++ 中，有多种基本数据类型可用于存储不同种类的数据。以下是 C++ 中一些常见的基本数据类型：
-
整数类型（Integer types）：
int：整数类型，通常为32位。short：短整数类型，通常为16位。long：长整数类型，通常为32位或64位。long long：更长的整数类型，通常为64位。
-
浮点数类型（Floating-point types）：
float：单精度浮点数，通常为32位。double：双精度浮点数，通常为64位。long double：更高精度的浮点数。
-
字符类型（Character types）：
char：字符类型，用于存储单个字符。
-
布尔类型（Boolean type）：
bool：布尔类型，用于存储逻辑值，即 true 或 false。
-
空类型（Void type）：
void：空类型，表示不返回任何值的函数或指针。
需要注意的是，这些基本数据类型可以根据编译器和操作系统有所变化，它们的大小和范围可能会有所差异。此外，C++ 还支持使用修饰符（如 unsigned、signed、const 等）来扩展或限制这些基本数据类型的特性。
示例代码：
#include <iostream>
int main() {
int age = 25;
double pi = 3.14159;
char grade = 'A';
bool isPassed = true;
std::cout << "年龄: " << age << std::endl;
std::cout << "圆周率: " << pi << std::endl;
std::cout << "成绩: " << grade << std::endl;
std::cout << "是否通过: " << isPassed << std::endl;
return 0;
}
上述代码中，我们使用不同的基本数据类型定义了变量（age、pi、grade、isPassed），并通过输出流对象 cout 将其值输出到屏幕上。
基本数据类型在 C++ 中起着重要的作用，它们用于存储和操作不同类型的数据，帮助我们进行各种计算和处理。根据实际需求选择合适的基本数据类型非常重要。
变量：
在 C++ 中，变量用于存储和操作数据。一个变量可以被赋予一个特定的数据类型，并且在程序运行期间可以改变其值。
变量的基本语法如下：
<数据类型> <变量名>; // 声明一个变量
<变量名> = <初始值>; // 初始化变量（可选）
其中，<数据类型> 表示变量的数据类型，例如 int、double、char 等，<变量名> 是变量的名称，<初始值> 用于初始化变量的值（可选）。
示例代码：
#include <iostream>
int main() {
int age; // 声明一个整数类型的变量
age = 25; // 初始化变量 age 的值为 25
double pi = 3.14159; // 声明并初始化一个双精度浮点数变量
char grade = 'A'; // 声明并初始化一个字符变量
std::cout << "年龄: " << age << std::endl;
std::cout << "圆周率: " << pi << std::endl;
std::cout << "成绩: " << grade << std::endl;
return 0;
}
上述代码中，我们声明了三个变量：age (整数类型)、pi (双精度浮点数类型) 和 grade (字符类型)。然后，通过赋值操作符将初始值赋给这些变量，并使用输出流对象 cout 将它们的值输出到屏幕上。
在 C++ 中，可以在声明变量的同时进行初始化，也可以单独进行赋值操作。需要注意的是，变量在使用之前必须先声明，即提供变量名和数据类型。
变量在程序中的作用类似于数学中的符号，可以用于存储数据并对其进行处理。在编写程序时，合理定义和使用变量是很重要的，它们可以帮助我们存储和操作各种类型的数据。
常量：
在 C++ 中，常量是指在程序运行期间不可更改的值。与变量不同，常量的值在声明后不能被修改。常量可以是整数、浮点数、字符等各种数据类型。
常量可以分为两种类型：字面常量（Literal Constants）和符号常量（Symbolic Constants）。
-
字面常量：字面常量是直接在代码中使用的常量值。
- 整数常量：例如 10、-5、0。
- 浮点数常量：例如 3.14、-2.5、0.0。
- 字符常量：用单引号括起来的单个字符，例如 'A'、'b'、'$'。
- 字符串常量：用双引号括起来的字符序列，例如 "Hello"、"World"。
-
符号常量：符号常量使用
const关键字进行声明，并在声明时初始化。- 使用
const关键字声明一个常量，并为其赋予一个初始值。 - 常量的名称通常全大写，多个单词之间使用下划线
_分隔开。
- 使用
示例代码：
#include <iostream>
// 符号常量的声明和定义
const int MAX_VALUE = 100;
const double PI = 3.14159;
const char NEW_LINE = '\n';
int main() {
// 字面常量的使用
int year = 2023;
double temperature = 25.5;
char symbol = '@';
std::string message = "Hello, world!";
std::cout << "年份: " << year << NEW_LINE;
std::cout << "温度: " << temperature << NEW_LINE;
std::cout << "符号: " << symbol << NEW_LINE;
std::cout << "消息: " << message << NEW_LINE;
return 0;
}
上述代码中，我们通过 const 关键字声明了几个符号常量：MAX_VALUE、PI 和 NEW_LINE。然后，我们使用这些常量来存储和输出不同类型的数据。
常量的使用可以提高代码的可读性和维护性，因为它们的值不会被修改。通过使用常量，我们可以避免在程序中硬编码值，并使代码更具有可扩展性和灵活性。
运算符与表达式：
在 C++ 中，运算符用于执行各种操作，例如算术运算、关系运算、逻辑运算等。通过使用运算符，可以创建表达式来进行数据计算和逻辑判断。
以下是常见的 C++ 运算符和表达式：
-
算术运算符：
- 加法
+：将两个值相加。 - 减法
-：从一个值中减去另一个值。 - 乘法
*：将两个值相乘。 - 除法
/：将一个值除以另一个值。 - 取余
%：返回两个数相除的余数。
- 加法
-
关系运算符：
- 等于
==：判断两个值是否相等。 - 不等于
!=：判断两个值是否不相等。 - 大于
>：判断左边的值是否大于右边的值。 - 小于
<：判断左边的值是否小于右边的值。 - 大于等于
>=：判断左边的值是否大于或等于右边的值。 - 小于等于
<=：判断左边的值是否小于或等于右边的值。
- 等于
-
逻辑运算符：
- 与
&&：当两个条件都为真时，结果为真。 - 或
||：当两个条件之一为真时，结果为真。 - 非
!：将真变为假，假变为真。
- 与
-
赋值运算符：
- 赋值
=：将右边的值赋给左边的变量。
- 赋值
-
其他常见运算符：
- 自增
++：将变量的值增加 1。 - 自减
--：将变量的值减少 1。 - 条件运算符
? :：根据条件的真假选择不同的值。 - 成员访问运算符
.：用于访问类的成员。 - 指针访问运算符
->：用于通过指针访问对象的成员。
- 自增
示例代码：
#include <iostream>
int main() {
int a = 5;
int b = 3;
int c;
// 算术运算符
c = a + b; // 加法
std::cout << "a + b = " << c << std::endl;
c = a - b; // 减法
std::cout << "a - b = " << c << std::endl;
c = a * b; // 乘法
std::cout << "a * b = " << c << std::endl;
c = a / b; // 除法
std::cout << "a / b = " << c << std::endl;
c = a % b; // 取余
std::cout << "a % b = " << c << std::endl;
// 关系运算符
bool result = (a == b); // 等于
std::cout << "a == b : " << result << std::endl;
result = (a != b); // 不等于
std::cout << "a != b : " << result << std::endl;
// 逻辑运算符
bool condition1 = true;
bool condition2 = false;
bool logicalAnd = (condition1 && condition2); // 与
std::cout << "condition1 && condition2 : " << logicalAnd << std::endl;
bool logicalOr = (condition1 || condition2); // 或
std::cout << "condition1 || condition2 : " << logicalOr << std::endl;
bool logicalNot = !condition1; // 非
std::cout << "!condition1 : " << logicalNot << std::endl;
// 赋值运算符
c = a; // 赋值
std::cout << "c = " << c << std::endl;
return 0;
}
上述代码演示了一些常见的运算符和表达式。你可以根据实际需求选择合适的运算符来进行计算和判断，以及使用适当的表达式来实现你所需的功能。
string 类：
在 C++ 中，string 类是用于处理字符串的标准库类。它提供了一系列的成员函数和操作符，方便对字符串进行操作和处理。
要使用 string 类，需要包含 <string> 头文件。
以下是 string 类的一些常用操作：
-
声明和初始化：
#include <string> std::string str1; // 声明一个空字符串 std::string str2 = "Hello"; // 使用字符串字面量初始化 std::string str3(str2); // 使用已有的字符串初始化 std::string str4 = str2 + " World";// 字符串拼接初始化 -
访问和修改字符串的内容：
std::string str = "Hello"; char ch = str[0]; // 访问字符串的第一个字符 std::cout << "First character: " << ch << std::endl; str[0] = 'h'; // 修改字符串的第一个字符 std::cout << "Modified string: " << str << std::endl; -
字符串长度和判空：
std::string str = "Hello"; int length = str.length(); // 获取字符串的长度 std::cout << "String length: " << length << std::endl; bool isEmpty = str.empty(); // 判断字符串是否为空 std::cout << "Is empty: " << (isEmpty ? "true" : "false") << std::endl; -
字符串拼接和连接：
std::string str1 = "Hello"; std::string str2 = " World"; std::string concat = str1 + str2; // 字符串拼接 std::cout << "Concatenated string: " << concat << std::endl; str1 += str2; // 字符串连接 std::cout << "Connected string: " << str1 << std::endl; -
字符串比较：
std::string str1 = "Hello"; std::string str2 = "World"; int compareResult = str1.compare(str2); // 比较字符串 if (compareResult == 0) { std::cout << "Strings are equal" << std::endl; } else if (compareResult < 0) { std::cout << "str1 is less than str2" << std::endl; } else { std::cout << "str1 is greater than str2" << std::endl; } -
子串操作：
std::string str = "Hello, World"; std::string substr = str.substr(7, 5); // 提取子串 std::cout << "Substring: " << substr << std::endl; size_t pos = str.find("World"); // 查找子串的位置 if (pos != std::string::npos) { std::cout << "Substring found at position: " << pos << std::endl; } else { std::cout << "Substring not found" << std::endl; }
string 类还提供了许多其他有用的成员函数和操作符，例如查找、替换、插入、删除等操作。通过使用这些功能，可以对字符串进行灵活的处理和操作。
需要注意的是，在处理大量字符串操作时，string 类可能会有一些性能损失。如果有需要高效处理大量字符串的场景，可以考虑使用 std::vector<char> 或 char[] 数组来代替 string 类
结构体 struct：
在 C++ 中，结构体（struct）是一种用户自定义的数据类型，用于组合多个不同类型的数据成员。结构体允许你将相关的数据作为一个整体进行组织，方便进行管理和操作。
以下是结构体的基本语法：
struct StructName {
// 数据成员
dataType1 member1;
dataType2 member2;
// ...
};
// 创建结构体对象
StructName objectName;
在上面的代码中，StructName 是结构体的名称，可以根据需要自定义。dataType1、dataType2 等是数据成员的类型，可以是任意合法的数据类型，包括内置类型如整型、浮点型，以及自定义类型如字符串或其他结构体。
通过实例化结构体对象，你可以访问和修改其中的成员：
objectName.member1 = value1; // 访问并设置成员值
value2 = objectName.member2; // 访问并获取成员值
结构体可以用于表示具有一组相关属性的对象。例如，当你需要存储一个人的信息时，可以使用结构体定义一个人的数据模型：
#include <iostream>
#include <string>
struct Person {
std::string name;
int age;
std::string address;
};
int main() {
Person person;
person.name = "Alice";
person.age = 25;
person.address = "123 Main Street";
std::cout << "Name: " << person.name << std::endl;
std::cout << "Age: " << person.age << std::endl;
std::cout << "Address: " << person.address << std::endl;
return 0;
}
在上述代码中，Person 是一个结构体类型，包含了一个姓名（name）、年龄（age）和地址（address）。通过实例化 Person 结构体对象，可以访问并设置其中的成员。
结构体还支持嵌套，可以在结构体中包含其他结构体作为成员，从而建立更复杂的数据模型。
使用结构体能够方便地组织和管理不同类型的数据成员，适用于需要表示一组相关属性或特征的情况。
703
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
