C++简单学习（Part1_lecture 2）（数据类型、变量类型、变量作用域、常量、修饰符类型）

Part 1 基本语法和使用

Lecture 2 数据类型、变量类型、变量作用域、常量、修饰符类型

目录

Part 1 基本语法和使用

Lecture 2 数据类型变量类型变量作用域常量修饰符类型

目录
数据类型

变量类型

变量作用域

常量

修饰符类型

1 数据类型

使用编程语言进行编程时，需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着，当您创建一个变量时，就会在内存中保留一些空间。

您可能需要存储各种数据类型（比如字符型、宽字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。



一些基本类型可以使用一个或多个类型修饰符进行修饰：

signed

unsigned

short

long

下表显示了各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。

注意：不同系统会有所差异。



从上表可得知，变量的大小会根据编译器和所使用的电脑而有所不同。

下面实例会输出您电脑上各种数据类型的大小。

#include<iostream>
#include<string>
#include <limits>
using namespace std;

int main()
{
cout << "short: \t\t"  << "所占字节数：" << sizeof(short);

cout << "\t最大值："  << (numeric_limits<short>::max)();

cout << "\t\t最小值："<< (numeric_limits<short>::min)() <<endl;
}

使用sizeof()函数获取各种数据类型的大小。

运行结果



typedef



enumeration枚举类型



笔记列表

#include <iostream>
using namespace std;

int main(){
enum days{one, two, three}day;
day = one;
switch(day){
case one:
cout << "one" << endl;
break;
case two:
cout << "two" << endl;
break;
default:
cout << "three" << endl;
break;
}
return 0;
}

输出结果：

one

枚举类型不一定要在main函数中定义

直接输出显示的是枚举的下标

#include <iostream>
using namespace std;
enum time {first,second,third,forth,fifth};

int main()
{
enum time a=fifth;
if (a==fifth)
{
cout << a <<endl;
cout << "Succeed!";
}
return 0;
}

运行结果：

4

Succeed!

枚举和switch随便做一个判断名次的举例

#include<iostream>
using namespace std;

int  main()
{
enum rank
{
first,second,third
};

int nRank=1;
switch (nRank)
{
case first:
cout << "第一名";
break;
case second:
cout << "第二名";
break;
case third:
cout << "第三名";
break;
default:
break;
}
// system("pause");
return 0;
}

运行结果：

第二名

2 变量类型

变量其实只不过是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C++ 是大小写敏感的。

基于前一章讲解的基本类型，有以下几种基本的变量类型，将在下一章中进行讲解：



C++ 也允许定义各种其他类型的变量，比如枚举、指针、数组、引用、数据结构、类等等，这将会在后续的章节中进行讲解。

下面我们将讲解如何定义、声明和使用各种类型的变量。





变量只能定义一次，可以使用extern关键字在多个文件中声明多次

尝试下面的实例

其中，变量在头部就已经被声明，但它们是在主函数内被定义和初始化的：

#include <iostream>
using namespace std;

// 变量声明
extern int a, b;
extern int c;
extern float f;

int main ()
{
// 变量定义
int a, b;
int c;
float f;

// 实际初始化
a = 10;
b = 20;
c = a + b;

cout << c << endl ;

f = 70.0/3.0;
cout << f << endl ;

return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

30

23.3333

同样的，在函数声明时，提供一个函数名，而函数的实际定义则可以在任何地方进行。例如：

// 函数声明
int func();

int main()
{
// 函数调用
int i = func();
}

// 函数定义
int func()
{
return 0;
}

笔记

3 变量作用域

在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。下面是一个实例：





全局变量系统自动初始化，局部变量系统不会自动初始化

定义变量时，最好进行初始化

笔记

#include <iostream>
using namespace std;

// 全局变量声明
int g = 99;

// 函数声明
int func();

int main()
{
// 局部变量声明
int g = 10;
cout << g << endl;
int kk = func();
cout << kk << endl;
return 0;
}

// 函数定义
int func()
{
return g;
}

运行结果：

10

99





运行结果：

此时的全局变量为：20

被改变的全局变量为：30

此时的全局变量为：30

4 常量

不能把true看成1，flase看成0

#include <iostream>
#include<string>

using namespace std;

int main()
{
string a="hello"",""worl""d";
cout<<a<<endl;
}

运行结果：

hello,world





把常量定义为大写字母形式，是很好的编程风格

笔记







const 限定符定以后是不可以改变的，所以在定义时赋初值，否则是错误的

除非这个变量是用extern修饰的外部变量

5 修饰符类型

为了理解 C++ 解释有符号整数和无符号整数修饰符之间的差别，我们来运行一下下面这个短程序：





笔记



explicit构造函数的作用

解析：

explicit构造函数是用来防止隐式转换的。请看下面的代码：

class Test1
{
public:
Test1(int n)
{
num=n;
}//普通构造函数
private:
int num;
};
class Test2
{
public:
explicit Test2(int n)
{
num=n;
}//explicit(显式)构造函数
private:
int num;
};
int main()
{
Test1 t1=12;//隐式调用其构造函数,成功
Test2 t2=12;//编译错误,不能隐式调用其构造函数
Test2 t2(12);//显式调用成功
return 0;
}

Test1的构造函数带一个int型的参数，代码23行会隐式转换成调用Test1的这个构造函数。而Test2的构造函数被声明为explicit（显式），这表示不能通过隐式转换来调用这个构造函数，因此代码24行会出现编译错误。

普通构造函数能够被隐式调用。而explicit构造函数只能被显式调用。



volatile 往往用于多线程的修饰