C++基本语法、数据类型、变量、常量

类的肤浅理解

现在让我们简要地看一下什么是类、对象、成员变量、成员方法：

• 类：可以表示一种类型事物，可以包含其属性和行为。
• 对象：对象是类的一个实例，它具有类包含的属性和行为。
• 成员变量：是类中定义的属性。
• 成员函数：是类中定义的方法。

例如狗：

有很多品种的狗，我们可以把狗这个种类定义为一个类。

狗的特征有：颜色、名称、品种等，这些特征就是我们的成员变量要表达的东西；

狗的行为有：摇动、叫唤、吃等，这些行为就是我们的成员函数要表达的东西。

对象就是狗类的一个真实例子，例如王二家有一个土狗，张三家有一个金毛。

C++ 标识符

1. C++ 标识符是用来标识变量、函数、类、命名空间等，或任何其他用户自定义类型的名称。
2. 一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。
3. C++ 标识符内不允许出现标点字符，比如 @、& 和 %。
4. C++ 是区分大小写的编程语言。

例如下面有效的标识符:

world       test    aaaa   dog_name  _a_123
MYDOG   _temp__   j     a23b9    _fas_23_AA

C++ 关键字

这些保留字不能作为常量名、变量名或其他标识符名称

asm	else	new	this
auto	enum	operator	throw
bool	explicit	private	true
break	export	protected	try
case	extern	public	typedef
catch	false	register	typeid
char	float	reinterpret_cast	typename
class	for	return	union
const	friend	short	unsigned
const_cast	goto	signed	using
continue	if	sizeof	virtual
default	inline	static	void
delete	int	static_cast	volatile
do	long	struct	wchar_t
double	mutable	switch	while
dynamic_cast	namespace	template	 

C++ 注释

/* 这是单行注释 */
int age = 10;

// 这也是单行注释
int grade = 1;
 
/* 
 * C++ 注释也可以
 * 跨行注释
 */
char* name = "duye";

C++ 数据类型

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

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

基本的内置类型
C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型：

类型	关键字
布尔型	bool
字符型	char
整型	int
浮点型	float
双浮点型	double
无类型	void

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

• signed
• unsigned
• short
• long

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

类型	位	范围
char	1 个字节	-128 到 127 或者 0 到 255
unsigned char	1 个字节	0 到 255
signed char	1 个字节	-128 到 127
int	4 个字节	-2147483648 到 2147483647
unsigned int	4 个字节	0 到 4294967295
signed int	4 个字节	-2147483648 到 2147483647
short int	2 个字节	-32768 到 32767
unsigned short int	2 个字节	0 到 65,535
signed short int	2 个字节	-32768 到 32767
long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int	8 个字节	-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int	8 个字节	0 to 18,446,744,073,709,551,615
float	4 个字节	+/- 3.4e +/- 38 (~7 个数字)
double	8 个字节	+/- 1.7e +/- 308 (~15 个数字)
long double	16 个字节	+/- 1.7e +/- 308 (~15 个数字)
wchar_t	2 或 4 个字节	1 个宽字符， 是一种扩展的存储方式，主要用在国际化程序的实现中

变量的大小会根据编译器和所使用的电脑而有所不同。

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

#include <iostream>  
#include <string>  
#include <limits>

using namespace std;  
  
int main() {  
    cout << "type: \t\t" << "************size**************"<< endl;  
    cout << "bool: \t\t" << "所占字节数：" << sizeof(bool);  
    cout << "\t最大值：" << (numeric_limits<bool>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<bool>::min)() << endl;  
    cout << "wchar_t: \t" << "所占字节数：" << sizeof(wchar_t);  
    cout << "\t最大值：" << (numeric_limits<wchar_t>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<wchar_t>::min)() << endl;  
    cout << "short: \t\t" << "所占字节数：" << sizeof(short);  
    cout << "\t最大值：" << (numeric_limits<short>::max)();  
    cout << "\t\t最小值：" << (numeric_limits<short>::min)() << endl;  
    cout << "int: \t\t" << "所占字节数：" << sizeof(int);  
    cout << "\t最大值：" << (numeric_limits<int>::max)();  
    cout << "\t最小值：" << (numeric_limits<int>::min)() << endl;  
    cout << "unsigned: \t" << "所占字节数：" << sizeof(unsigned);  
    cout << "\t最大值：" << (numeric_limits<unsigned>::max)();  
    cout << "\t最小值：" << (numeric_limits<unsigned>::min)() << endl;  
    cout << "long: \t\t" << "所占字节数：" << sizeof(long);  
    cout << "\t最大值：" << (numeric_limits<long>::max)();  
    cout << "\t最小值：" << (numeric_limits<long>::min)() << endl;  
    cout << "unsigned long: \t" << "所占字节数：" << sizeof(unsigned long);  
    cout << "\t最大值：" << (numeric_limits<unsigned long>::max)();  
    cout << "\t最小值：" << (numeric_limits<unsigned long>::min)() << endl;  
    cout << "double: \t" << "所占字节数：" << sizeof(double);  
    cout << "\t最大值：" << (numeric_limits<double>::max)();  
    cout << "\t最小值：" << (numeric_limits<double>::min)() << endl;  
    cout << "long double: \t" << "所占字节数：" << sizeof(long double);  
    cout << "\t最大值：" << (numeric_limits<long double>::max)();  
    cout << "\t最小值：" << (numeric_limits<long double>::min)() << endl;  
    cout << "float: \t\t" << "所占字节数：" << sizeof(float);  
    cout << "\t最大值：" << (numeric_limits<float>::max)();  
    cout << "\t最小值：" << (numeric_limits<float>::min)() << endl;  
    cout << "size_t: \t" << "所占字节数：" << sizeof(size_t);  
    cout << "\t最大值：" << (numeric_limits<size_t>::max)();  
    cout << "\t最小值：" << (numeric_limits<size_t>::min)() << endl;
    
    return 0;  
}

结果：当上面的代码被编译和执行时，它会产生以下的结果，结果会根据所使用的计算机而有所不同：

type:           ************size**************
bool:           所占字节数：1   最大值：1               最小值：0
wchar_t:        所占字节数：4   最大值：2147483647              最小值：-2147483648
short:          所占字节数：2   最大值：32767           最小值：-32768
int:            所占字节数：4   最大值：2147483647      最小值：-2147483648
unsigned:       所占字节数：4   最大值：4294967295      最小值：0
long:           所占字节数：8   最大值：9223372036854775807     最小值：-9223372036854775808
unsigned long:  所占字节数：8   最大值：18446744073709551615    最小值：0
double:         所占字节数：8   最大值：1.79769e+308    最小值：2.22507e-308
long double:    所占字节数：16  最大值：1.18973e+4932   最小值：3.3621e-4932
float:          所占字节数：4   最大值：3.40282e+38     最小值：1.17549e-38
size_t:         所占字节数：8   最大值：18446744073709551615    最小值：0

---

typedef 声明

可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：

typedef type newname;

例如，下面的语句会告诉编译器，int32 是 int 的另一个名称：

typedef int int32;

现在，下面的声明是完全合法的，它创建了一个整型变量 age：

int32 age = 0;

---

枚举类型

枚举类型是由用户定义的若干枚举常量的集合。
例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 “blue”。

// 定义类型
enum color { red, green, blue };

// 定义变量并赋初值
color c = green;

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，green 的值为 5。

enum color { red, green=5, blue };

上例中，red依然是从0开始，blue是6，他是按照前一个值往后递增。

C++ 变量类型

• 变量其实只不过是程序可操作的存储区的名称。
• C++ 中每个变量都有指定的类型，即所谓的强类型语言。
• 类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中。
• 运算符可应用于变量上。
• 变量的名称可以由字母、数字和下划线字符组成。
• 它必须以字母或下划线开头。
• 大写字母和小写字母是不同的，因为 C++ 是大小写敏感的。

C++ 中的变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type variable_list;

type 必须是一个有效的 C++ 数据类型，可以是 char、wchar_t、int、float、double、bool 或任何用户自定义的对象，variable_list 可以由一个或多个标识符名称组成，多个标识符之间用逗号分隔。下面列出几个有效的声明：

int    i, j, k;
char   c, ch;
float  f, salary;
double d;

变量可以在声明的时候被初始化（指定一个初始值）。初始化器由一个等号，后跟一个常量表达式组成，如下所示：

type variable_name = value;

下面列举几个实例：

int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z
char x = 'x';               // 变量 x 的值为 'x'

C++ 变量作用域

作用域是程序的一个区域，一般来说有三个地方可以定义变量：

• 在函数或一个代码块内部声明的变量，称为局部变量。
• 在函数参数的定义中声明的变量，称为形式参数。
• 在所有函数外部声明的变量，称为全局变量。
• 在类中定义的变量，称为成员变量。

局部变量

• 在函数或一个代码块内部声明的变量，称为局部变量。
• 它们只能被函数内部或者代码块内部的语句使用。

实例：

  1 #include <iostream>
  2 
  3 void def_var();
  4 
  5 int main() {
  6     // 局部变量
  7     def_var();
  8     
  9     return 0;
 10 }   
 11 
 12 void def_var() {
 13     int a = 10;
 14     int b = 20;
 15     int c = a + b;
 16     
 17     std::cout << "a = " << a << std::endl;
 18     std::cout << "b = " << b << std::endl;
 19     std::cout << "c = " << c << std::endl;
 20     
 21     {
 22         std::cout << "a = " << a << std::endl;
 23         
 24         int d = 30;
 25         std::cout << "d = " << d << std::endl;
 26     }   
 27 }     

结果：

a = 10
b = 20
c = 30
a = 10
d = 30

全局变量

• 在所有函数外部定义的变量（通常是在程序的头部），称为全局变量。
• 全局变量的值在程序的整个生命周期内都是有效的。
• 全局变量可以被任何函数访问。也就是说，全局变量一旦声明，在整个程序中都是可用的。

实例：

  1 #include <iostream>
  2 
  3 int g = 5;
  4 
  5 void print_var();
  6 
  7 int main() {
  8 
  9     print_var();
 10 
 11     std::cout << "g in main = " << g << std::endl;
 12 
 13     return 0;
 14 }
 15 
 16 void print_var() {
 17     std::cout << "g in print_var = " << g << std::endl;
 18 } 

结果：

g in print_var = 5
g in main = 5

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

实例：

  1 #include <iostream>
  2 
  3 int g = 5;
  4 
  5 void print_var();
  6 
  7 int main() {
  8 
  9     print_var();
 10 
 11     std::cout << "g in main = " << g << std::endl;
 12 
 13     return 0;
 14 }
 15 
 16 void print_var() {
 17     int g = 10;
 18     std::cout << "g in print_var = " << g << std::endl;
 19 }

结果：

g in print_var = 10
g in main = 5

初始化局部变量和全局变量

• 当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化，不然是一个随机值。
  实例：

  1 #include <iostream>
  2 int main() {
  3     int a;
  4     int b;
  5     int c;
  6     int d;
  7     int e;
  8     int f;
  9 
 10     std::cout << "a = " << a << std::endl;
 11     std::cout << "b = " << b << std::endl;
 12     std::cout << "c = " << c << std::endl;
 13     std::cout << "d = " << d << std::endl;
 14     std::cout << "e = " << e << std::endl;
 15     std::cout << "f = " << f << std::endl;
 16 
 17     return 0;
 18 }

结果：

a = 0
b = 0
c = 32765
d = 876087424
e = 0
f = 4196304

• 定义全局变量时，系统会自动初始化为下列值：

数据类型	初始化默认值
int	0
char	‘\0’
float	0
double	0
pointer	NULL

实例:

  1 #include <iostream>
  2 int a;
  3 char b;
  4 float c;
  5 double d;
  6 int* p;
  7 
  8 int main() {
  9 
 10     std::cout << "a = " << a << std::endl;
 11     std::cout << "b = " << b << std::endl;
 12     std::cout << "c = " << c << std::endl;
 13     std::cout << "d = " << d << std::endl;
 14     std::cout << "p = " << p << std::endl;
 15 
 16     return 0;
 17 }

结果：

a = 0
b = 
c = 0
d = 0
p = 0

正确地初始化变量是一个良好的编程习惯，否则有时候程序可能会产生意想不到的结果，所以请务必初始化局部变量。

C++ 常量

• 常量是固定值，在程序执行期间不会改变。
• 这些固定的值，又叫做字面量。
• 常量可以是任何的基本数据类型，可分为整型数字、浮点数字、字符、字符串和布尔值。

定义常量

在 C++ 中，有两种简单的定义常量的方式：

• 使用 #define 预处理器。
• 使用 const 关键字。

#define 预处理器

#define identifier value

实例：

  1 #include <iostream>
  2 
  3 #define LENGTH 10
  4 #define WIDTH 10
  5 #define AREA "area = "
  6 
  7 int main() {
  8 
  9     std::cout << AREA << LENGTH * WIDTH << std::endl;
 10 
 11     return 0;
 12 }

结果：

area = 100

const 关键字

const type variable = value;

实例：

  1 #include <iostream>
  2 
  3 const int LENGTH = 10;
  4 const int WIDTH = 10;
  5 const char* AREA = "area = ";
  6 
  7 int main() {
  8 
  9     std::cout << AREA << LENGTH * WIDTH << std::endl;
 10     
 11     return 0;
 12 } 

结果：

area = 100

有兴趣的朋友，请关注微信公众号，有机会获取平台代币：

进入社区贡献者微信群，有机会获取平台代币：