C++ 学习（二）变量、常量、关键字、标识符命名规则、数据类型

瘦身小蚂蚁

已于 2022-07-22 19:15:50 修改

阅读量1.1k

点赞数

分类专栏： C++ Golang 文章标签： c++

于 2022-07-19 19:20:22 首次发布

本文链接：https://blog.csdn.net/ling1998/article/details/125862927

版权

Golang 同时被 2 个专栏收录

25 篇文章 1 订阅

订阅专栏

C++

21 篇文章 10 订阅

订阅专栏

变量

作用：给一段指定的内存空间起名，方便管理这段内存空间

常量

作用：记录程序中不可更改的数据，即只读数据

C++变量与常量

变量

语法：数据类型变量名 = 变量初始值;

常量

两种定义方式：

1、 #define 宏常量： #define 常量名常量值（定义在文件的上方；注：结尾没有分号）

宏定义的常量没有类型，它是在编译前（预编译阶段）进行字符替换，同时没有类型的安全检查，系统也不会为它分配内存，因此宏常量地址是不能被访问的。

2、 const修饰的变量：const 数据类型常量名 = 常量值;

#include <iostream>
using namespace std;

//宏常量： #define 常量名 常量值 （注：结尾没有分号）
#define Path "F:/"

int main()
{
	//变量：数据类型 变量名 = 变量初始值;
	int age = 20;
	cout << "变量 age = " << age << endl;

	cout << "宏常量 Path = " << Path << endl;

	//常量：const修饰的变量 => const 数据类型 常量名 = 常量值;
	const int MaxValue = 1000;
	cout << "常量 MaxValue = " << MaxValue << endl;

	system("pause");

	return 0;
}

Go语言变量与常量

Go语言中，常量地址是不允许访问的

package main

import "fmt"

//常量定义在函数外面
const Path = "F:/"

func main() {
	//变量
	var age int = 20;
	fmt.Println("变量 age = ", age)
	fmt.Println("常量 Path = ", Path)

	//常量定义在函数内部
	const MaxValue = 1000
	fmt.Println("常量 MaxValue = ", MaxValue)

	//Go语言，常量地址是不允许访问的，下面写法语义会报错
	//fmt.Printf("常量地址 MaxValue = %p", &MaxValue)
}

关键字

关键字是预先保留的单词。

在给变量或常量起名时，不要使用关键字，否则会产生歧义。

C++关键字

asm	auto	bad _cast	bad _typeid
bool	break	case	catch
char	class	const	const _cast
continue	default	delete	do
double	dynamic _cast	else	enum
except	explicit	extern	false
finally	float	for	friend
goto	if	inline	int
long	mutable	namespace	new
operator	private	protected	public
register	reinterpret _cast	return	short
signed	sizeof	static	static _cast
struct	switch	template	this
throw	true	try	type _info
typedef	typeid	typename	union
unsigned	using	virtual	void
volatile	wchar_t	wchar_t

Go语言关键字与预定义标识符

25个关键字

break	default	func	interface	select
case	defer	go	map	struct
chan	else	goto	package	switch
const	fallthrough	if	range	type
continue	for	import	return	var

36个预定义标识符

append	bool	byte	cap	close	complex	complex64	complex128	uint16
copy	false	float32	float64	imag	int	int8	int16	uint32
int32	int64	iota	len	make	new	nil	panic	uint64
print	println	real	recover	string	true	uint	uint8	uintptr

标识符命名规则

不能是关键字

只能由字母、数字、下划线组成

第一个字符必须为字母或下划线

字母区分大小写

给变量起名时最好是见名知意。

Go语言标识符命名规则与 C++ 相同。

数据类型

给变量分配合适的内存空间

整型

C++整型

数据类型	占用空间	取值范围
short	2字节	$-2^{15}$ ~ $2^{15}$ -1
int	4字节	$-2^{31}$ ~ $2^{31}$ -1
long	windows 4字节； linux32位为4字节，linux64位为8字节	$-2^{31}$ ~ $2^{31}$ -1
long long	8字节	$-2^{63}$ ~ $2^{63}$ -1

Go语言整型

数据类型	占用空间	取值范围
int8	1字节	-128 ~ 127
int16	2字节	$-2^{15}$ ~ $2^{15}$ -1
int32	4字节	$-2^{31}$ ~ $2^{31}$ -1
int64	8字节	$-2^{63}$ ~ $2^{63}$ -1
int	32位操作系统为4字节，64位操作系统为8字节	$-2^{31}$ ~ $2^{31}$ -1 $-2^{63}$ ~ $2^{63}$ -1
uint8	1字节	0 ~ 255
uint16	2字节	0 ~ $2^{16}$ -1
uint32	4字节	0 ~ $2^{32}$ -1
uint64	8字节	0 ~ $2^{64}$ -1
uint	32位操作系统为4字节，64位操作系统为8字节	0 ~ $2^{32}$ -1 0 ~ $2^{64}$ -1

内存大小

C++ sizeof关键字

统计数据类型所占内存大小。

语法：sizeof(数据类型或变量)

#include <iostream>
using namespace std;

int main()
{
	short n1 = 10;
	int n2 = 10;
	long n3 = 10;
	long long n4 = 10;

	//sizeof
	cout << "short占用内存空间 = " << sizeof(short) << endl;
	cout << "short类型变量n1占用内存空间 = " << sizeof(n1) << endl;

	cout << "int占用内存空间 = " << sizeof(int) << endl;
	cout << "int类型变量n2占用内存空间 = " << sizeof(n2) << endl;

	cout << "long占用内存空间 = " << sizeof(long) << endl;
	cout << "long类型变量n3占用内存空间 = " << sizeof(n3) << endl;

	cout << "long long占用内存空间 = " << sizeof(long long) << endl;
	cout << "long long类型变量n4占用内存空间 = " << sizeof(n4) << endl;

	system("pause");

	return 0;
}

运行结果

short占用内存空间 = 2
short类型变量n1占用内存空间 = 2
int占用内存空间 = 4
int类型变量n2占用内存空间 = 4
long占用内存空间 = 4
long类型变量n3占用内存空间 = 4
long long占用内存空间 = 8
long long类型变量n4占用内存空间 = 8

Go语言 unsafe.Sizeof(变量名)

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var n1 int8 = 10
	var n2 int16 = 10
	var n3 int32 = 10
	var n4 int64 = 10
	var n5 int = 10

	var u1 uint8 = 10
	var u2 uint16 = 10
	var u3 uint32 = 10
	var u4 uint64 = 10
	var u5 uint = 10

	fmt.Println("int8类型变量n1占用内存空间 = ", unsafe.Sizeof(n1))
	fmt.Println("int16类型变量n2占用内存空间 = ", unsafe.Sizeof(n2))
	fmt.Println("int32类型变量n3占用内存空间 = ", unsafe.Sizeof(n3))
	fmt.Println("int64类型变量n4占用内存空间 = ", unsafe.Sizeof(n4))
	fmt.Println("int类型变量n5占用内存空间 = ", unsafe.Sizeof(n5))

	fmt.Println("uint8类型变量u1占用内存空间 = ", unsafe.Sizeof(u1))
	fmt.Println("uint16类型变量u2占用内存空间 = ", unsafe.Sizeof(u2))
	fmt.Println("uint32类型变量u3占用内存空间 = ", unsafe.Sizeof(u3))
	fmt.Println("uint64类型变量u4占用内存空间 = ", unsafe.Sizeof(u4))
	fmt.Println("uint类型变量u5占用内存空间 = ", unsafe.Sizeof(u5))
}

运行结果

int8类型变量n1占用内存空间 = 1
int16类型变量n2占用内存空间 = 2
int32类型变量n3占用内存空间 = 4
int64类型变量n4占用内存空间 = 8
int类型变量n5占用内存空间 = 8
uint8类型变量u1占用内存空间 = 1
uint16类型变量u2占用内存空间 = 2
uint32类型变量u3占用内存空间 = 4
uint64类型变量u4占用内存空间 = 8
uint类型变量u5占用内存空间 = 8

浮点型

表示小数，浮点型底层参考：浮点数的表示方法_我知道你是高手的博客-CSDN博客_浮点数表示方法

C++浮点型

数据类型	占用空间	有效数字范围
float（单精度）	4字节	7位有效数字
double（双精度）	8字节	16位有效数字

默认情况下输出一个小数，会显示6位有效数字

#include <iostream>
using namespace std;

int main()
{
	//单精度
	float f1 = 3.1415926f;
	//双精度
	double d1 = 3.1415926;

	cout << "float类型变量 f1 = " << f1 << endl;
	cout << "float占用内存空间 = " << sizeof(float) << endl;
	cout << "float类型变量f1占用内存空间 = " << sizeof(f1) << endl;

	cout << "double类型变量 d1 = " << d1 << endl;
	cout << "double占用内存空间 = " << sizeof(double) << endl;
	cout << "double类型变量d1占用内存空间 = " << sizeof(d1) << endl;

	//科学计数法
	float f2 = 3e4;
	cout << "float类型变量(科学计数法) f2 = " << f2 << endl;

	system("pause");

	return 0;
}

输出结果

float类型变量 f1 = 3.14159
float占用内存空间 = 4
float类型变量f1占用内存空间 = 4
double类型变量 d1 = 3.14159
double占用内存空间 = 8
double类型变量d1占用内存空间 = 8
float类型变量(科学计数法) f2 = 30000

Go语言浮点型

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var f32 float32 = 3.141592653589793238462
	var f64 float64 = 3.141592653589793238462

	fmt.Println("float32类型变量 f32 = ", f32)
	fmt.Println("float32类型变量f32占用内存空间 = ", unsafe.Sizeof(f32))
	fmt.Println("float64类型变量 f32 = ", f64)
	fmt.Println("float64类型变量f364占用内存空间 = ", unsafe.Sizeof(f64))

	//科学计数法
	var f2 float32 = 3e4
	fmt.Println("float32类型变量(科学计数法) f2 = ", f2)
}

输出结果

float32类型变量 f32 = 3.1415927
float32类型变量f32占用内存空间 = 4
float64类型变量 f32 = 3.141592653589793
float64类型变量f364占用内存空间 = 8

float32类型变量(科学计数法) f2 = 30000

字符型

用于显示单个字符

C++字符型

语法：char 变量名称 = '单个字符';

注：使用单引号括起来，且只能是一个字符，字符型只占一个字节

字符型变量是将对应的ASCII编码放入到存储单元，而不是将字符本身放到内存存储，如小写字母‘a’对应的ASCII编码为97，则内存存储的是97，而不是'a'

ASCII编码表参考：ASCII 表 | 菜鸟教程

#include <iostream>
using namespace std;

int main()
{
	//字符型
	char ch = 'a';

	cout << "char类型变量 ch = " << ch << endl;
	cout << "char占用内存空间 = " << sizeof(char) << endl;
	cout << "char类型变量ch占用内存空间 = " << sizeof(ch) << endl;
	cout << "char类型变量ch对应的ASCII编码 = " << (int)ch << endl;

	system("pause");

	return 0;
}

输出结果

char类型变量 ch = a
char占用内存空间 = 1
char类型变量ch占用内存空间 = 1
char类型变量ch对应的ASCII编码 = 97

Go语言字符型

支持ASCII编码与Unicode编码

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	//支持ASCII编码
	fmt.Println("----byte类型表示字符（ASCII编码）----")

	var ch byte = 'a'

	fmt.Printf("byte类型变量 ch = %c\n", ch)
	fmt.Println("byte类型变量ch占用内存空间 = ", unsafe.Sizeof(ch))
	fmt.Println("byte类型变量ch对应的ASCII编码 = ", int(ch))


	fmt.Println("----int8类型表示字符（ASCII编码）----")

	var ch1 int8 = 'a'

	fmt.Printf("int8类型变量 ch1 = %c\n", ch1)
	fmt.Println("int8类型变量ch1占用内存空间 = ", unsafe.Sizeof(ch1))
	fmt.Println("int8类型变量ch1对应的ASCII编码 = ", int(ch1))


	//支持Unicode，使用int 或 rune类型表字符
	fmt.Println("----int类型表示字符（Unicode编码）----")

	var ch2 int = '\u0061' //十六进制表示
	fmt.Printf("int类型变量 ch2 = %c\n", ch2)
	fmt.Println("int类型变量ch2占用内存空间 = ", unsafe.Sizeof(ch2))
	fmt.Println("int类型变量ch2对应的Unicode编码 = ", ch2)

	fmt.Println("----rune类型表示字符（Unicode编码）----")

	var ch3 rune = 19990
	fmt.Printf("rune类型变量 ch3 = %c\n", ch3)
	fmt.Println("rune类型变量ch3占用内存空间 = ", unsafe.Sizeof(ch3))
	fmt.Println("rune类型变量ch3对应的Unicode编码 = ", ch3)

	fmt.Println("----rune类型表示字符（Unicode编码）----")

	var ch4 rune = '世'
	fmt.Printf("rune类型变量 ch4 = %c\n", ch4)
	fmt.Println("rune类型变量ch4占用内存空间 = ", unsafe.Sizeof(ch4))
	fmt.Println("rune类型变量ch4对应的Unicode编码 = ", ch4)
}

输出结果

----byte类型表示字符（ASCII编码）----
byte类型变量 ch = a
byte类型变量ch占用内存空间 = 1
byte类型变量ch对应的ASCII编码 = 97
----int8类型表示字符（ASCII编码）----
int8类型变量 ch1 = a
int8类型变量ch1占用内存空间 = 1
int8类型变量ch1对应的ASCII编码 = 97
----int类型表示字符（Unicode编码）----
int类型变量 ch2 = a
int类型变量ch2占用内存空间 = 8
int类型变量ch2对应的Unicode编码 = 97
----rune类型表示字符（Unicode编码）----
rune类型变量 ch3 = 世
rune类型变量ch3占用内存空间 = 4
rune类型变量ch3对应的Unicode编码 = 19990
----rune类型表示字符（Unicode编码）----
rune类型变量 ch4 = 世
rune类型变量ch4占用内存空间 = 4
rune类型变量ch4对应的Unicode编码 = 19990

转义字符

表示一些不能显示出来的ASCII字符，如换行符、制表符等，下表中常用的转义字符使用加粗字体标识：

转义字符	意义	ASCII码值（十进制）
\a	响铃(BEL)	007
\b	退格(BS) ，将当前位置移到前一列	008
\f	换页(FF)，将当前位置移到下页开头	012
\n	换行(LF) ，将当前位置移到下一行开头	010
\r	回车(CR) ，将当前位置移到本行开头	013
\t	水平制表(HT) （跳到下一个TAB位置）	009
\v	垂直制表(VT)	011
\\	代表一个反斜线字符''\'	092
\'	代表一个单引号（撇号）字符	039
\"	代表一个双引号字符	034
\?	代表一个问号	063
\0	空字符(NUL)	000
\ddd	1到3位八进制数所代表的任意字符	三位八进制
\xhh	十六进制所代表的任意字符	十六进制

字符串

表示一串字符

C++字符串

两种风格：

C风格： char 变量名[] = "字符串";

C++风格：string 变量名 = "字符串"; （需要包含头文件#include <string>）

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

int main()
{
	//字符串
	//C风格
	char str[] = "Hello, Tracy!";
	cout << "C风格字符串str[] = " << str << endl;

	//C++风格，需要包含头文件#include <string>
	string str1 = "Hello, Tracy!";
	cout << "C++风格字符串str1 = " << str1 << endl;

	system("pause");

	return 0;
}

输出结果

C风格字符串str[] = Hello, Tracy!
C++风格字符串str1 = Hello, Tracy!

Go语言字符串

package main

import "fmt"

func main() {
	var str string = "Hello, Tracy!"
	fmt.Println("字符串变量 str = ", str)

	str1 := "Hello, Tracy!"
	fmt.Println("字符串变量 str1 = ", str1)
}

输出结果

字符串变量 str = Hello, Tracy!
字符串变量 str1 = Hello, Tracy!

布尔类型

表示真或假的值，占用1字节内存空间

C++布尔类型

语法：bool 变量名 = true 或 false; 或是 bool 变量名 = 1或 0;

bool类型需要赋值才能使用（即没有默认值），否则报错。

bool类型实际输出结果为 0 或 1。

#include <iostream>
using namespace std;

int main()
{
	//布尔类型
	bool success = false; //success = 0; 

	cout << "bool类型变量 success = " << success << endl;
	cout << "bool占用内存空间 = " << sizeof(bool) << endl;
	cout << "bool类型变量success占用内存空间 = " << sizeof(success) << endl;

	success = true;  // success = 1;
	cout << "bool类型变量 success = " << success << endl;

	system("pause");

	return 0;
}

输出结果

bool类型变量 success = 0
bool占用内存空间 = 1
bool类型变量success占用内存空间 = 1
bool类型变量 success = 1

Go语言布尔类型

Go语言布尔类型有默认值为false，且值只能表示true或false，不能使用0或1

package main

import "fmt"

func main() {
	var success bool
	fmt.Println("bool类型变量默认值 success = ", success)
	fmt.Println("bool类型变量占用空间 = ", unsafe.Sizeof(success))

	success = true
	fmt.Println("bool类型变量设置为true success = ", success)

	success = false
	fmt.Println("bool类型变量设置为false success = ", success)
}

输出结果

bool类型变量默认值 success = false
bool类型变量占用空间 = 1
bool类型变量设置为true success = true
bool类型变量设置为false success = false

数据的输入

从键盘获取数据

C++数据的输入

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

int main()
{
	//数据的输入
	int i;
	cout << "请输入一个整型：" << endl;
	cin >> i;
	cout << "您输入的整型变量 i = " << i << endl;

	float f;
	cout << "请输入一个浮点型：" << endl;
	cin >> f;
	cout << "您输入的浮点型变量 f = " << f << endl;

	char c;
	cout << "请输入一个字符型：" << endl;
	cin >> c;
	cout << "您输入的字符型变量 c = " << c << endl;

	string str;  //注意在头文件加上#include <string>
	cout << "请输入一个字符串型（不含空格）：" << endl;
	cin >> str;
	cout << "您输入的字符串型（不含空格）变量 str = " << str << endl;

	string str1;
	cout << "请输入一个字符串型（含空格）：" << endl;
	cin >> str1;
	getline(cin, str1); //若出现空格，则只能获取空格前字符串，因此使用getline
	cout << "您输入的字符串型（含空格）变量 str1 = " << str1 << endl;

	bool b;
	cout << "请输入一个布尔型：" << endl;
	cin >> b;	//只要非0都代表真
	cout << "您输入的布尔型变量 b = " << b << endl;

	system("pause");

	return 0;
}

输出结果（键盘输入内容已加粗）

请输入一个整型：
22
您输入的整型变量 i = 22
请输入一个浮点型：
3.14159269793
您输入的浮点型变量 f = 3.14159
请输入一个字符型：
a
您输入的字符型变量 c = a
请输入一个字符串型（不含空格）：
hello
您输入的字符串型（不含空格）变量 str = hello
请输入一个字符串型（含空格）：
I am Tracy.
您输入的字符串型（含空格）变量 str1 = am Tracy.
请输入一个布尔型：
1
您输入的布尔型变量 b = 1

Go语言数据的输入

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	//数据的输入
	var i int
	fmt.Println("请输入一个整型：")
	fmt.Scan(&i)
	fmt.Println("您输入的整型变量 i = ", i)

	var f float32
	fmt.Println("请输入一个浮点型：")
	fmt.Scan(&f)
	fmt.Println("您输入的浮点变量 f = ", f)

	var c byte
	fmt.Println("请输入一个字符型：")
	fmt.Scanf("%c", &c)
	fmt.Printf("您输入的字符变量 c = %c\n", c)

	//scan、scanf、scanln在输入时，会以空格作为一个字符串的结束
	var str string
	fmt.Println("请输入一个字符串型（不含空格）：")
	fmt.Scan(&str)
	fmt.Printf("您输入的字符串（不含空格）变量 str = %s\n", str)

	fmt.Println("请输入一个字符串型（含空格）：")
	reader := bufio.NewReader(os.Stdin)
	str1, _, err := reader.ReadLine()
	if err != nil {
		fmt.Println("错误：", err)
	}
	fmt.Printf("您输入的字符串（含空格）str1 = %s\n", str1)

	var b bool
	fmt.Println("请输入一个布尔型：")
	fmt.Scan(&b)
	fmt.Println("您输入的布尔变量 b = ", b)
}

输出结果（键盘输入内容已加粗）

请输入一个整型：
22
您输入的整型变量 i = 22
请输入一个浮点型：
3.14159269793
您输入的浮点变量 f = 3.1415927
请输入一个字符型：
a
您输入的字符变量 c = a
请输入一个字符串型（不含空格）：
hello
您输入的字符串（不含空格）变量 str = hello
请输入一个字符串型（含空格）：
I am Tracy.
您输入的字符串（含空格）str1 = I am Tracy.
请输入一个布尔型：
true
您输入的布尔变量 b = true