C++（一） - Echo's Blog

C++基本语法:常量、变量、关键字、标识符、数据类型（整形、浮点型、字符型、字符串型、布尔型）。

C++ (一)：常量、变量、关键字、标识符、数据类型(整形、浮点型、字符型、字符串型、布尔型)
C++ (二)：选择、循环、嵌套、跳转语句
C++ (三)：数组、函数
C++ (四)：指针、结构体

常量

常量，用于记录程序中不可更改的数据。

一旦你定义了一个常量并赋值，就无法在之后的语句中修改这个常量的值。常量是不可变的，它们的值在整个程序执行期间保持不变。如果你想在程序中使用可变的值，应该使用变量而不是常量。

C++定义常量两种方式，如下所示：

define 宏常量：#define 常量名常量值。通常在文件上方定义，表示一个常量。

#include <iostream>
using namespace std;
#define Day 7
int main()
{
    /*
    Day = 14;  //错误，Day是常量，一旦修改就会报错
    cout << "一周总共有：" << Day << "天" << endl;
    */
    cout << "一周总共有：" << Day << "天" << endl;
    // 输出语句：cout << "提示语" << 变量 << endl; 
    system("pause");
    return 0;
}

const修饰的变量: const 数据类型常量名 = 常量值;。通常在变量定义前加关键字const，修饰该变量为常量，不可修改。

#include <iostream>
using namespace std;
int main()
{
    /*
    const int month = 12;
    month = 24;  //错误，const修饰的变量也称为常量
    */
    int month = 12;
    month = 24;  //正确，这样可以修改变量的值
    cout << "一年总共有：" << month << "个月" << endl;
    system("pause");
    return 0;
}

变量

变量的作用就是就是给一段指定的内存空间起名，方便操作这段内存。

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

变量存在的意义：方便我们管理内存空间。

每一段内存都有一个地址编号。

C++规定在创建一个常量或变量时，必须要指出相应的数据类型，否则无法给变量分配内存。

#include <iostream>
using namespace std;
int main()
{
    //变量创建的语法：数据类型 变量名 = 变量初始值
    int a = 10;  
    cout << "a = " << a << endl;   // 输出语句 cout << "提示语" << 变量 << endl; 
    system("pause");
    return 0;
}

关键字

关键字是C++中预先保留的单词(标识符)。

关键字不能作为变量或者常量的名称。

常用的关键字有：auto，break，if，case，const，void，sizeof.....

int关键字:用于声明整数类型

#include <iostream>
using namespace std;
int main()
{
    // int int = 10;  // 错误，第二个int是关键字，不可以作为变量的名称
    system("pause");
    return 0;
}

sizeof关键字:统计数据类型所占内存空间大小

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

整形占用内存空间：Windows环境下:short(2) int(4) long(4) long long(8)。64位Linux环境下long占8字节。

#include <iostream>
using namespace std;
int main()
{
    cout << "short 类型所占内存空间为：" << sizeof(short) << endl;
    system("pause");
    return 0;
}

标识符

标识符就是 C++ 给变量、常量的命名。

标识符有一套自己的命名规则：

标识符不能使关键字。
标识符只能由字母、数字、下划线组成。
第一个字符必须为字母或下划线。
标识符中字母区分大小写。

建议：给标识符命名时，争取做到见名知意，方便自己和他人的阅读。

#include <iostream>
using namespace std;
int main()
{
    //1、标识符不可以是关键字
    //int int = 10;  //报错

    //2、标识符由字母、数字、下划线构成
    int abc       =   10;
    int _abc      =   20;
    int _123abc   =   40;

    //3、标识符第一个字符只能是字母或下划线
    //int 123abc = 50; //报错

    //4、标识符区分大小写
    int aaa = 100;
    //cout << AAA << endl; //报错，AAA和aaa不是同一个名称

    //建议：给变量起名的时候，最好能够做到见名知意
    int num1 = 10;
    int num2 = 20;
    int sum = num1 + num2; //建议用num1、num2、sum表示加法，而不是用a、b、c来表示
    cout << sum << endl;

    system("pause");

    return 0
}

数据类型

整形:整型变量表示的是整数类型的数据。

C++中能够表示整形的类型有以下几种方式，区别在于所占内存空间不同。

数据类型	占用空间	取值范围
short(短整型)	2字节	$-2^{15}$ ～ $2^{15}-1$
int（整型）	4字节	$-2^{31}$ ～ $2^{31}-1$
long(长整型）	Windows为4字节，Linux为4字节(32位)，8字节(64位)	$-2^{31}$ ～ $2^{31}-1$
long long(长长整型)	8字节	$-2^{63}$ ～ $2^{63}-1$

实型（浮点型）:表示小数

浮点型变量分为下面两种，两个的区别在于表示有效数字范围不同

单精度：float
双精度：double

数据类型	占用字节	有效数字范围
float	4字节	7位
double	8字节	15-16位

2.1 单精度、双精度

#include <iostream>
using namespace std;

int main()
{
    //1、单精度  float
    //2、双精度  double
    //默认情况下，无论单精度还是双精度，都只会显示6位有效数字
    float f1 = 3.1415926;  //默认为双精度，前面加float相当于把双精度转换为单精度
    float f2 = 3.1415926f;  //后面加一个f，直接创建的是单精度，省去了转换的过程

    cout << "f1 = ：" << f1 << endl;            // 3.14159

    double d1 = 3.1415926;

    cout << "d1 = ：" << d1 << endl;            // 3.14159

    cout << "float  占用内存空间为" << sizeof(float) << endl;        // float 占用内存空间为4
    cout << "double 占用内层空间为" << sizeof(double) << endl;        // double 占用内层空间为8

    system("pause");
    return 0;
}

2.2 科学计数法

#include <iostream>
using namespace std;

int main()
{
    //科学计数法
    float f3 = 3e2;          // 3 * (10 ^ 2)
    cout << "f3 = ：" << f3 << endl;        // f3 = ：300

    float f4 = 3e-2;         // 3 * (0.1 ^ 2)
    cout << "f4 = ：" << f4 << endl;        //f4 = ：0.03

    system("pause");
    return 0;
}

字符型:用于显示单个字符。

语法：char ch = 'a';

在显示字符型变量时，用单引号字符括起来，不要用双引号。

单引号内只能有一个字符，不可以是字符串。

C和C++中字符型变量只占用1个字节。

字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元。

ASCII码大致由以下两部分组成：

ASCII非打印控制字符：ASCII表上的数字0-31分配给了控制字符，用于控制像打印机等一些外围设备。
ASCII打印字符：数字21-126分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。

#include <iostream>
using namespace std;

int main()
{

    //1、字符型变量创建方式
    char ch = 'a';
    cout << ch << endl;        // a

    //2、字符型变量所占内存大小
    cout << "char字符型变量所占内存：" << sizeof(ch) << endl;        // char字符型变量所占内存：1

    //3、字符型变量常见错误
    char ch2 = 'b';  //创建字符型变量时候，要用单引号
    //char ch3 = "b";  //错误，创建字符型变量时候，不能用双引号
    //char ch4 = 'abcdef'; //错误，创建字符型变量时候，单引号内只能有一个字符

    //4、字符型变量对应ASCII编码
    cout << (int)ch << endl;   // (int)ch 为字符'a'的ASCIII码值        // 97

    system("pause");
    return 0;
}

字符串型:用于表示一串字符

字符串型有两种风格

C风格字符串：char 变量名[] = "字符串值"。
- 字符数组的大小等于字符串的长度加上一个用于存储字符串结尾的空字符 '\0' 的额外空间。所以，char类型的的内存大小会等于字符串长度加 1。
C++风格字符串：string 变量名 = "字符串值"。
- std::string 类型的大小包含了字符串的长度以及一些额外的元数据，通常会包含一个指向堆上分配的字符串数据的指针。因此，string的内存大小会比字符串的长度大一些。

具体的大小取决于编译器和平台，但通常情况下，std::string 会占用更多的内存空间。

#include <iostream>
using namespace std;

int main()
{

    //1、C风格字符串
    //char 字符   =    这是一个字符
    //char 字符[] =    这是一个字符串
    //表示字符串时，等号后面，要用双引号

    char str[] = "hello world";
    cout << str << endl;        // hello world

    //2、C++风格字符串
    string str2 = "hello world";
    cout << str2 << endl;        // hello world

    system("pause");
    return 0;
}

布尔类型 bool:代表真或假的值

bool类型只有两个值：

true -- 真 (本质是1)
false -- 假(本质是0)

bool类型占1个字节大小

#include <iostream>
using namespace std;

int main()
{
    //1、创建bool数据类型

    bool flag1 = true; //true代表真
    cout << flag1 << endl;                // 1

    bool flag2 = false; //flag 代表假
    cout << flag2 << endl;                // 0

    //本质上 1代表真 0代表假

    //2、查看bool类型所占空间
    cout << "bool所占内存空间：" << sizeof(flag1) << endl;        // bool所占内存空间：1
    cout << "bool所占内存空间：" << sizeof(flag2) << endl;        // bool所占内存空间：1

    system("pause");
    return 0;
}

转义字符：用于表示一些不能显示出来的ASCII字符

我们常用的转义字符有：\n、\、\t。

#include <iostream>
using namespace std;

int main()
{
    //换行符 \n

    cout << "hello world\n";

    //反斜杠 \\    要输出反斜杠\时，要在前面加上一个反斜杠

    cout << "\\" << endl;

    //水平制表符\t  可以整齐的输出数据
    cout << "aaaa\thellowworld" << endl;
    cout << "aa\thellowworld" << endl;
    cout << "aaaaaa\thellowworld" << endl;

    system("pause");

    return 0;
}

输出为：

数据输入

作用：用于从键盘获取数据。

数据的输入，关键字：cin

数据饿输入，语法：cin >> 变量

#include <iostream>
using namespace std;
#include <string>  //包含string的头文件
int main()
{

    //1、创建bool数据类型
    int a = 0;
    cout << "请给整型变量 a 赋值：" << endl;
    cin >> a;
    cout << "整型变量a = " << a << endl;

    //2、浮点型
    float f = 3.14f;
    cout << "请给浮点型变量 f 赋值：" << endl;
    cin >> f;
    cout << "浮点型变量 f = " << f << endl;

    //3、字符型
    char ch ;  //仅仅声明了，没有初始化
    cout << "请给字符型变量 ch 赋值：" << endl;
    cin >> ch;
    cout << "字符型变量 ch = " << ch << endl;

    //4、字符型
    string str = "hello";
    cout << "请给字符串 str 赋值：" << endl;
    cin >> str;
    cout << "字符型变量 str = " << str << endl;

    //4、布尔型
    bool flag = false;
    cout << "请给布尔类型 flag 赋值：" << endl;
    cin >> flag;   //布尔类型  只要是非0的值都代表真
    cout << "布尔类型 flag = " << flag << endl;

    system("pause");

    return 0;

}

输出:

请给整型变量 a 赋值：
23
整型变量a = 23
请给浮点型变量 f 赋值：
23.4
浮点型变量 f = 23.4
请给字符型变量 ch 赋值：
w
字符型变量 ch = w
请给字符串 str 赋值：
asfg
字符型变量 str = asfg
请给布尔类型 flag 赋值：
4562
布尔类型 flag = 1
请按任意键继续. . .

运算符

作用：用于执行代码的运算。

运算符类型主要有四种：

算术运算符：用于处理四则运算。
赋值运算符：用于将表达式的值赋给变量
比较运算符：用于表达式的比较，并返回一个真值或假值。
逻辑运算法：用于表达式的值返回真值或假值。

算术运算符

两个int类型相除，结果依然是整数,将小数部分去掉,只保留整数部分
两个浮点型可以相除,得到的是小数

#include <iostream>
using namespace std;

int main()
{

    int a1 = 10;
    int b1 = 3;

    cout << a1 + b1 << endl;        //13
    cout << a1 - b1 << endl;        //7
    cout << a1 * b1 << endl;        //30
    cout << a1 / b1 << endl;  //两个整数相除，结果依然是整数，将小数部分去除    //3

    int a2 = 10;
    int b2 = 20;

    cout << a2 / b2 << endl;        //0

    int a3 = 10;
    int b3 = 0;

    //cout << a3 / b3 << endl;  //两个数相除，除数不可以为0

    //两个小数可以相除
    double d1 = 0.51;        //如果d1为0.5，运算结果为整数2
    double d2 = 0.25;

    cout << d1 / d2 << endl; //运算结果也可以是小数    //2.04

    system("pause");

    return 0;

}

取模运算

语法:a % b

#include <iostream>
using namespace std;

int main()
{
    //取摸运算本质  就是求余数
    int a1 = 10;
    int b1 = 3;

    cout << a1 % b1 << endl;        //1

    /*两个数相除，除数不可以为0，所以也做不了取模运算
    int a2 = 10;
    int b2 = 0;

    cout << a2 % b2 << endl;  //
    */

    /*两个小数是不可以做取模运算的
    double d1 = 3.14;
    double d2 = 1.1;

    cout << d1 % d2 << endl;
    */

    system("pause");

    return 0;

}

递增递减运算

前置递增:++a

后置递增:a++

前置递增，先让变量+1 然后进行表达式运算

后置递增，先进行表达式运算，后让变量+1

#include <iostream>
using namespace std;

int main()
{
    //1、前置递增

    int a = 10;
    ++a;
    cout << "a=" << a << endl;        //a=11

    //2、后置递增

    int b = 15;
    b++;
    cout << "b=" << b << endl;        //b=16

    //3、前置和后置的区别
    //前置递增，先让变量+1 然后进行表达式运算
    int a2 = 10;
    int b2 = ++a2 * 10;
    cout << "a2= " << a2 << endl;        //a2= 11
    cout << "b2= " << b2 << endl;        //b2=110

    //后置递增，先进行表达式运算，后让变量+1
    int a3 = 10;
    int b3 = a3++ * 10;
    cout << "a3= " << a3 << endl;        //a3=11
    cout << "b3= " << b3 << endl;        //b3=100

    system("pause");

    return 0;

}

赋值运算符

#include <iostream>
using namespace std;

int main()
{

    // = 赋值
    int a = 10;
    a = 100;
    cout << "a= " << a << endl;        //a=100

    // += 加等于
    int b = 10;
    b = 10;
    b += 2;
    cout << "b= " << b << endl;        //b=12

    // -= 减等于
    int c = 10;
    c = 10;
    c -= 2;
    cout << "c= " << c << endl;        //c=8

    // *= 乘等于
    int d = 10;
    d = 10;
    d *= 2;
    cout << "d= " << d << endl;        //d=20

    // /= 除等于
    int e = 10;
    e = 10;
    e /= 2;
    cout << "e= " << e << endl;        //e=5

    // %= 模等于
    int f = 10;
    f = 10;
    f %= 2;
    cout << "f= " << f << endl;        //f=0

    system("pause");

    return 0;

}

比较运算符

作用：用于表达式的比较，并返回一个真值或假值。

真值输出为1,假值输出为0

#include <iostream>
using namespace std;

int main()
{
    //比较运算符

    // ==
    int a = 10;
    int b = 20;
    cout << (a == b) << endl;        //0

    // !=
    cout << (a != b) << endl;        //1

    // >
    cout << (a > b) << endl;        //0

    // <
    cout << (a < b) << endl;        //1

    // >=
    cout << (a >= b) << endl;        //0

    // <=
    cout << (a <= b) << endl;        //1

    system("pause");

    return 0;

}

逻辑运算符

作用：用于根据表达式的值返回真值或假值。

在C++中除了0，其余数都为真

!a 表示非，如果a为假，则!a为真；如果a为真，则!a为假。
a&&b 表示与，如果a和b都为真，则结果为真，否则为假。
a||b 表示或，如果a和b有一个为真，则结果为真，二者都为假时，结果为假。

#include <iostream>
using namespace std;

int main()
{
    //逻辑运算符

    // !=
    int a = 10;
    int b = 30;

    cout << (!a) << endl;  //在C++中除了0，都为真        //0
    cout << (!!a) << endl;                            //1

    // &&
    a = 10;
    b = 30;

    cout << (a && b) << endl;            //1

    a = 0;
    b = 10;
    cout << (a && b) << endl;            //0

    // ||
    a = 10;
    b = 30;
    cout << (a || b) << endl;            //1

    a = 0;
    b = 10;
    cout << (a || b) << endl;            //1

    a = 0;
    b = 0;
    cout << (a || b) << endl;            //0

    system("pause");

    return 0;
}