昨天思考了一下,感觉明白了。于是报名了软考,还有挑战z杯,想着四级还要不要报,毕竟我也不是有天赋的人,就只能努力去做个努力的人。加油!!! 不知道未来怎么样,那就走好现在吧!!!
C++语言中有多种类型,包括基本数据类型、复合数据类型和用户自定义类型。以下是C++的一些常见类型:
1. 基本数据类型(Primitive Data Types):
- 整数类型:int、short、long、long long、unsigned等。
- 浮点数类型:float、double。
- 字符类型:char、wchar_t、char16_t、char32_t。
- 布尔类型:bool。
2. 复合数据类型(Compound Data Types):
- 数组(Array):存储相同类型的多个元素的集合。
- 结构体(Struct):将不同类型的数据聚集到一个对象中。
- 联合体(Union):使用相同的内存位置存储不同类型的数据。
- 枚举(Enum):定义具有离散取值集合的新类型。
3. 指针类型(Pointer Types):
- 指针(Pointer):存储内存地址的变量,用于间接访问和修改数据。
- 空指针(nullptr):表示指针不指向任何有效的内存位置。
- 空类型指针(void*):指向未知类型的指针。
4. 引用类型(Reference Types):
- 引用(Reference):为变量起别名,在声明时使用&操作符。
5. 常量类型(Constant Types):
- const:用于声明常量,值不能被修改。
- constexpr:用于在编译时计算表达式的常量。
6. 自定义类型(User-defined Types):
- 类(Class):封装数据和函数的用户定义类型。
- 枚举类(Enum class):具有强类型和作用域的枚举类型。
- 联合体(Union):使用相同的内存位置存储不同类型的数据。
- 结构体(Struct):将不同类型的数据聚集到一个对象中。
- 类型别名(Typedef):为现有类型创建新的类型名称。
- using 声明(using declaration):引入命名空间中的特定成员。
其中bool类型是一个字节,char类型一个字节,wchar_t为宽字符为16个字节。。。
int整形通常是四个字节,不过在计算中我们通常作为16个字节数。
通常是精度较高的类型向较低类型转换可以,反之则不行。
在C++中,变量的作用域决定了变量在程序中的可见性和生命周期。以下是几种常见的变量作用域及其代码案例:
1. 全局作用域(Global Scope):
- 在函数体外部声明的变量具有全局作用域,可以在整个程序中访问。
- 示例代码:
```cpp
#include
int globalVariable = 10; // 全局变量
void printGlobalVariable() {
std::cout << "Global variable: " << globalVariable << std::endl;
}
int main() {
printGlobalVariable(); // 输出:Global variable: 10
return 0;
}
```2. 块作用域(Block Scope):
- 在函数、语句块或循环中声明的变量具有块作用域,只能在其所在的块或内层块中访问。
- 示例代码:
```cpp #include
void printNumber() { int number = 5; // 块作用域变量 std::cout << "Number: " << number << std::endl; } int main() { printNumber(); // 输出:Number: 5 // std::cout << number; // 错误:无法访问printNumber函数中的number变量 return 0; } ``` 3. 函数参数作用域(Function Parameter Scope):
- 函数参数具有函数参数作用域,只能在函数体内部访问。
- 示例代码:
```cpp #include
void printName(std::string name) { std::cout << "Name: " << name << std::endl; } int main() { std::string myName = "Alice"; // 局部变量 printName(myName); // 输出:Name: Alice // std::cout << name; // 错误:无法访问printName函数中的name参数 return 0; } ``` 4. 类作用域(Class Scope):
- 在类定义中声明的成员变量具有类作用域,可以在整个类中访问。
- 示例代码:
```cpp #include
class MyClass { public: int memberVariable = 20; // 类成员变量 void printMemberVariable() { std::cout << "Member variable: " << memberVariable << std::endl; } }; int main() { MyClass obj; obj.printMemberVariable(); // 输出:Member variable: 20 return 0; } ``` 这些是变量作用域的几个常见示例,每个作用域都有其特定的可见范围和生命周期。正确使用变量的作用域可以提高代码的可读性、避免命名冲突以及有效地管理变量的生命周期。
#include
using namespace std;
int main()
{
int b = 10;
int *a=&b;
int** c = &a;
cout << **c<< endl;
return 0;
}
在代码中*a=&b a的值等于b的地址,与就是 a的值为&b,*a就是指向a的值的地址的值,就是指向&b位置的值。
指针和引用是C++语言中两种不同的机制,它们都可以用于间接操作内存中的值,但是它们之间有以下几个最大的区别:
1. 指针和引用的定义方式不同:
- 指针是一个变量,其存储的值为另一个变量的地址,需要使用*(解引用运算符)来获取所指向的值。指针可以为空或NULL,可以被重新赋值指向不同的内存地址。
- 引用是一个已经存在的变量的别名,一旦被定义,就不能被改变指向其他变量,也不能为空或NULL。2. 指针和引用的用途不同:
- 指针通常用于动态内存分配、数组及链表等数据结构的实现,以及函数参数传递。
- 引用通常用于函数的返回值、函数参数传递和类的成员变量。3. 指针和引用的空间占用不同:
- 指针在32位系统中通常占用4个字节,在64位系统中通常占用8个字节,而且每次访问指针变量时都需要额外的开销。
- 引用本身不占用额外的内存空间,它只是原变量的另一个名称,所以访问引用的速度通常比访问指针快。4. 指针和引用的空值处理不同:
- 指针可以为空或NULL,需要在使用时进行判断,否则可能会导致程序崩溃。
- 引用不能为NULL或空,一旦被定义,就必须指向一个已经存在的变量。
顶层const:表示指针是一个常量
底层const:表示指针所指的是一个常量
**顶层 const
**:
const
出现在对象的最顶层,表示对象本身是一个常量。这意味着你不能通过这个指针或引用来修改对象的值,但可以改变指针或引用指向其他对象。const int x = 5; // x 是一个顶层 const,不可修改
int const y = 10; // 与上面相同,x 和 y 是等价的
const int* ptr = &x; // ptr 是一个指向常量整数的指针,不允许通过 ptr 修改 x 的值
复制
**底层 const
**:
const
出现在对象的底层,表示对象本身可修改,但不能通过这个指针或引用来修改对象的值。int a = 5;
int const* ptr = &a; // ptr 是一个指向整数常量的指针,a 是可修改的,但不能通过 ptr 修改 a 的值
const int* constPtr = &a; // 同上,ptr 和 constPtr 是等价的
const
在函数参数中常用于指明参数是只读的,从而防止函数内部修改参数的值。void foo(const int x) {
// 在函数内部,x 是只读的,不能修改它的值
}
总结一下:
const
表示对象本身是常量,不能被修改。const
表示指向的对象是常量,但指针或引用本身可以修改`constexpr` 是 C++11 引入的关键字,用于声明常量表达式。常量表达式是在编译时就可以计算出结果的表达式,它具有以下特点:
1. 在编译时求值:常量表达式的值必须在编译时能够确定,不能依赖于运行时的输入或其他动态操作。
2. 编译时优化:编译器可以对常量表达式进行求值,并在编译期间进行优化,减少运行时的开销。
3. 用于常量定义:常量表达式可以用于定义常量变量,并在程序中使用。
使用 `constexpr` 关键字声明常量表达式时,需要满足一定的条件:
1. 表达式必须是编译时可求值的,不能含有任何可能运行时才能确定的值或操作。
2. 表达式中只能使用内置类型、字面值、函数调用(如果函数本身也是 `constexpr` 的),以及支持的运算符。
3. 声明常量表达式的函数本身也要被声明为 `constexpr`。
下面是一个示例代码,演示了如何使用 `constexpr` 声明和使用常量表达式:
```cpp
#include
constexpr int square(int x) {
return x * x;
}
int main() {
constexpr int radius = 5;
constexpr int area = square(radius) * 3.14;
std::cout << "半径为 " << radius << " 的圆的面积是 " << area << std::endl;
return 0;
}
```
在上面的代码中,`square` 函数被声明为 `constexpr`,它接受一个整数参数并返回该整数的平方。在 `main` 函数中,使用 `constexpr` 声明了常量 `radius` 和 `area`,并通过调用 `square` 函数计算圆的面积。由于所有的操作都是在编译时确定的,因此 `area` 的计算也可以在编译期间完成。
类型别名
typedef
是 C++ 中的一个关键字,用于为类型定义一个新的别名或类型名。通过使用 typedef
,可以为已有的类型赋予一个更具描述性的名称,提高代码的可读性和可维护性。
typedef
的语法形式如下:
typedef 原类型 新类型名;
其中,原类型
表示要定义别名的已有类型,新类型名
是所定义的新类型。
下面是一些 typedef
的常见用法示例:
typedef int myInt; // 将 int 类型定义为 myInt
typedef double Distance; // 将 double 类型定义为 Distance
typedef int* IntPtr; // 将 int* 类型定义为 IntPtr
typedef struct {
int x;
int y;
} Point; // 将匿名结构体定义为 Point
typedef void (*FunctionPtr)(int); // 将函数指针定义为 FunctionPtr,指向接受 int 参数且返回值为 void 的函数
在上述示例中,我们使用 typedef
分别为 int
、double
、int*
、匿名结构体以及函数指针定义了新的类型名。使用这些新类型名时,就相当于使用原类型。
typedef
在 C++ 中广泛用于提高代码的可读性和可维护性。它特别适用于复杂的类型和函数指针的声明,可以避免编写冗长的类型名,并使代码更加清晰易懂。然而,自 C++11 起,还引入了更加灵活和强大的类型别名机制 using
,建议在新的代码中使用 using
来替代 typedef
。例如,上述示例可以改写为以下形式:
using myInt = int;
using Distance = double;
using IntPtr = int*;
struct Point {
int x;
int y;
};
using FunctionPtr = void (*)(int);
`decltype` 是 C++11 中引入的一个类型指示符(type specifier)。它用于从表达式中推导出其类型,并在编译时确定该表达式的类型。
`decltype` 的语法形式如下:
decltype(expression)其中,`expression` 是一个有效的 C++ 表达式,可以是任意合法的表达式,包括变量、函数调用、运算符操作等。
`decltype` 主要有两种使用方式:
1. 推导变量的类型:通过 `decltype` 可以根据变量的初始化表达式来推导出变量的类型。例如:
```cpp int x = 5; decltype(x) y; // 推导出 y 的类型为 int ```
这里 `decltype(x)` 推导出的类型为 `int`,因为变量 `x` 的初始化表达式是整数值 5。
2. 推导表达式的类型:通过 `decltype` 可以根据表达式来推导出该表达式的类型。例如:
```cpp int a = 10; double b = 5.5; auto result = a + b; decltype(a + b) sum; // 推导出 sum 的类型为 double ```
这里 `decltype(a + b)` 推导出的类型为 `double`,因为表达式 `a + b` 的结果是一个浮点数。
需要注意的是,`decltype` 不会执行表达式,只负责推导表达式的类型。此外,如果表达式是一个变量名而不是一个初始化表达式,`decltype` 推导的类型将是该变量声明时的类型。例如:
```cpp int x = 5; decltype(x) y = x; // 推导出 y 的类型为 int ```
`decltype` 是一个非常有用的类型指示符,可以在编译时获取表达式的类型,并且能够根据变量初始化表达式来推导出变量的类型。它可以用于声明变量、定义函数返回类型等场景,提高代码的可读性和灵活性。