【C++】C++学习（一）

数据类型

1. 声明

typedef：可以声明各种类型名，但不能用来定义变量
#define：宏定义

typedef unsigned int UINT;
#define f(x) x*x
int main()
{
	UINT value = "abc";
    int a=6, b=2, c;
    c=f(a) / f(b);
    printf("%d\n", c);
    return 0;
}
1
2
3
4
5
6
7
8
9
10

typedef 与 #define的区别

• 执行时间不同
  typedef ：在编译阶段有效，由于是在编译阶段，因此 typedef 有类型检查的功能。
  #define ：是宏定义，发生在预处理阶段，也就是编译之前，它只进行简单而机械的字符串替换，而不进行任何检查。

• 功能有差异
  typedef ：用来定义类型的别名，定义与平台无关的数据类型，与 struct 的结合使用等。
  #define ：不只是可以为类型取别名，还可以定义常量、变量、编译开关等。

• 作用域不同
  #define ：没有作用域的限制，只要是之前预定义过的宏，在以后的程序中都可以使用。
  typedef ：有自己的作用域。

下面关于typedef和#define对指针的操作的示例：

typedef int * pint;
#define PINT int *
 
int i1 = 1, i2 = 2;
 
const pint p1 = &i1;    //p不可更改，p指向的内容可以更改，相当于 int * const p;
const PINT p2 = &i2;    //p可以更改，p指向的内容不能更改，相当于 const int *p；或 int const *p；
 
pint s1, s2;    //s1和s2都是int型指针
PINT s3, s4;    //相当于int * s3，s4；只有一个是指针。
1
2
3
4
5
6
7
8
9
10

2. 类型准换

• 静态转换（Static Cast）：静态转换是将一种数据类型的值强制转换为另一种数据类型的值。
• 动态转换（Dynamic Cast）：通常用于将一个基类指针或引用转换为派生类指针或引用。动态转换在运行时进行类型检查，如果不能进行转换则返回空指针或引发异常。
• 常量转换（Const Cast）：常量转换用于将 const 类型的对象转换为非 const 类型的对象。
• 重新解释转换（Reinterpret Cast）：重新解释转换将一个数据类型的值重新解释为另一个数据类型的值，通常用于在不同的数据类型之间进行转换。

//静态转换
int i = 10;
float f = static_cast<float>(i); // 静态将int类型转换为float类型

//动态转换
class Base {};
class Derived : public Base {};
Base* ptr_base = new Derived;
Derived* ptr_derived = dynamic_cast<Derived*>(ptr_base); // 将基类指针转换为派生类指针

//常量转换
const int i = 10;
int& r = const_cast<int&>(i); // 常量转换，将const int转换为int

//重新解释转换
int i = 10;
float f = reinterpret_cast<float&>(i); // 重新解释将int类型转换为float类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

我重新搜了一下重新解释转换和静态转换的区别，好像是重新解释转换相较于静态转换，可以用于进行各种类型之间的强制转换，包括指针、引用、整数之间的转换，会改变数据的原本含义。

但是目前我对基本的数据类型转换都是直接用 强转来进行转换的。

float i = 10.0;
int f = (int)(i); 
1
2

变量作用域

局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。

#include 
using namespace std;

int g = 20;		// 全局变量声明
int main ()
{
	 int g = 10;	// 局部变量声明
	 cout << g;
	 return 0;
}
1
2
3
4
5
6
7
8
9
10

结果:10
1

static 全局变量：改变作用范围，不改变存储位置

static 局部变量：改变存储位置，不改变作用范围

静态函数 ：在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。

如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数也称为内部函数。定义一个内部函数，只需在函数类型前再加一个“static”关键字即可。

#include 
using namespace std;

int count = 1; //全局变量

int fun()
{
    static int count = 10; // 在第一次进入这个函数的时候，变量 count 被初始化为 10！并接着自减 1，以后每次进入该函数，count 的值是上一次函数运行之后的值
    return count--;        // 就不会被再次初始化了，仅进行自减 1 的操作；在 static 发明前，要达到同样的功能，则只能使用全局变量
}
1
2
3
4
5
6
7
8
9
10