菜鸟教程 -- 学的不仅是技术,更是梦想!

C++ 教程
C++ 教程 C++ 简介 C++ 环境设置 C++ 基本语法 C++ 注释 C++ 数据类型 C++ 变量类型 C++ 变量作用域 C++ 常量 C++ 修饰符类型 C++ 存储类 C++ 运算符 C++ 循环 C++ 判断 C++ 函数 C++ 数字 C++ 数组 C++ 字符串 C++ 指针 C++ 引用 C++ 日期 & 时间 C++ 基本的输入输出 C++ 结构体(struct) C++ vector 容器 C++ 数据结构

C++ 面向对象

C++ 类 & 对象 C++ 继承 C++ 重载运算符和重载函数 C++ 多态 C++ 数据抽象 C++ 数据封装 C++ 接口(抽象类)

C++ 高级教程

C++ 文件和流 C++ 异常处理 C++ 动态内存 C++ 命名空间 C++ 模板 C++ 预处理器 C++ 信号处理 C++ 多线程 C++ Web 编程

C++ 资源库

C++ STL 教程 C++ 导入标准库 C++ 标准库 C++ 有用的资源 C++ 实例 C++ 测验 C++ <iostream> C++ <fstream> C++ <sstream> C++ <iomanip> C++ <array> C++ <vector> C++ <list> C++ <forward_list> C++ <deque> C++ <stack> C++ <queue> C++ <priority_queue> C++ <set> C++ <unordered_set> C++ <map> C++ <unordered_map> C++ <bitset> C++ <algorithm> C++ <iterator> C++ <functional> C++ <numeric> C++ <complex> C++ <valarray> C++ <cmath> C++ <string> C++ <regex> C++ <ctime> C++ <chrono> C++ <thread> C++ <mutex> C++ <condition_variable> C++ <future> C++ <atomic> C++ <type_traits> C++ <typeinfo> C++ <exception> C++ <stdexcept> C++ <cstdio> C++ <cstdint> C++ <memory> C++ <new> C++ <utility> C++ <random> C++ <locale> C++ <codecvt> C++ <cassert> C++ <cwchar> C++ <climits> C++ <cfloat> C++ <cstdlib> C++ <numbers> C++ OpenCV
(追記) (追記ここまで)

C++ 常量

常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量

常量可以是任何的基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔值。

常量就像是常规的变量,只不过常量的值在定义后不能进行修改。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数:0x 或 0X 表示十六进制,0 表示八进制,不带前缀则默认表示十进制。

整数常量也可以带一个后缀,后缀是 U 和 L 的组合,U 表示无符号整数(unsigned),L 表示长整数(long)。后缀可以是大写,也可以是小写,U 和 L 的顺序任意。

下面列举几个整数常量的实例:

212// 合法的215u// 合法的0xFeeL// 合法的078// 非法的:8 不是八进制的数字032UU// 非法的:不能重复后缀

以下是各种类型的整数常量的实例:

85// 十进制0213// 八进制 0x4b// 十六进制 30// 整数 30u// 无符号整数 30l// 长整数 30ul// 无符号长整数

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时,必须包含整数部分、小数部分,或同时包含两者。当使用指数形式表示时, 必须包含小数点、指数,或同时包含两者。带符号的指数是用 e 或 E 引入的。

下面列举几个浮点常量的实例:

3.14159// 合法的 314159E-5L// 合法的 510E// 非法的:不完整的指数210f// 非法的:没有小数或指数 .e55// 非法的:缺少整数或分数

布尔常量

布尔常量共有两个,它们都是标准的 C++ 关键字:

  • true 值代表真。
  • false 值代表假。

我们不应把 true 的值看成 1,把 false 的值看成 0。

字符常量

字符常量是括在单引号中。如果常量以 L(仅当大写时)开头,则表示它是一个宽字符常量(例如 L'x'),此时它必须存储在 wchar_t 类型的变量中。否则,它就是一个窄字符常量(例如 'x'),此时它可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符(例如 'x')、一个转义序列(例如 '\t'),或一个通用的字符(例如 '\u02C0')。

在 C++ 中,有一些特定的字符,当它们前面有反斜杠时,它们就具有特殊的含义,被用来表示如换行符(\n)或制表符(\t)等。下表列出了一些这样的转义序列码:

转义序列含义
\\\ 字符
\' ' 字符
\"" 字符
\?? 字符
\a警报铃声
\b退格键
\f换页符
\n换行符
\r回车
\t水平制表符
\v垂直制表符
\ooo一到三位的八进制数
\xhh . . .一个或多个数字的十六进制数

下面的实例显示了一些转义序列字符:

实例

#include<iostream>usingnamespacestd; intmain(){cout << "Hello\tWorld\n\n"; return0; }

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

Hello World

字符串常量

字符串字面值或常量是括在双引号 "" 中的。一个字符串包含类似于字符常量的字符:普通的字符、转义序列和通用的字符。

您可以使用 \ 做分隔符,把一个很长的字符串常量进行分行。

下面的实例显示了一些字符串常量:

实例

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

int main() {
string greeting = "hello, runoob";
cout << greeting;
cout << "\n"; // 换行符
string greeting2 = "hello, \
runoob"
;
cout << greeting2;
return 0;
}
hello, runoob
hello, runoob

定义常量

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

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

#define 预处理器

下面是使用 #define 预处理器定义常量的形式:

#define identifier value

具体请看下面的实例:

实例

#include<iostream>usingnamespacestd; #defineLENGTH10#defineWIDTH5#defineNEWLINE '\n'intmain(){intarea; area = LENGTH * WIDTH; cout << area; cout << NEWLINE; return0; }

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

50

const 关键字

您可以使用 const 前缀声明指定类型的常量,如下所示:

const type variable = value;

具体请看下面的实例:

实例

#include<iostream>usingnamespacestd; intmain(){constintLENGTH = 10; constintWIDTH = 5; constcharNEWLINE = '\n'; intarea; area = LENGTH * WIDTH; cout << area; cout << NEWLINE; return0; }

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

50

请注意,把常量定义为大写字母形式,是一个很好的编程实践。


AI 思考中...

13 篇笔记 写笔记

  1. #0

    绝罗

    419***[email protected]

    252

    定义成 const 后的常量,程序对其中只能读不能修改。

    以下程序是错误的,因为开头就已经固定了常量,便不能再对其进行赋值:

    #include <iostream>
    using namespace std;
    int main()
    {
     const double pi; //圆周率的值用pi表示
     pi=3.14159265;
     cout<<"圆周率的近似值是"<<pi<<endl;
     return 0;
    }
    

    下面给出正确的赋值方法:

    #include <iostream>
    using namespace std;
    int main()
    {
     const double pi=3.141592; //圆周率的值用pi表示
     cout<<"圆周率的近似值是"<<pi<<endl;
     return 0;
    }
    

    绝罗

    419***[email protected]

    9年前 (2017年04月21日)
  2. #0

    宏定义 #define 和常量 const 的区别

    类型和安全检查不同

    宏定义是字符替换,没有数据类型的区别,同时这种替换没有类型安全检查,可能产生边际效应等错误;

    const常量是常量的声明,有类型区别,需要在编译阶段进行类型检查

    编译器处理不同

    宏定义是一个"编译时"概念,在预处理阶段展开,不能对宏定义进行调试,生命周期结束与编译时期;

    const常量是一个"运行时"概念,在程序运行使用,类似于一个只读行数据

    存储方式不同

    宏定义是直接替换,不会分配内存,存储于程序的代码段中;

    const常量需要进行内存分配,存储于程序的数据段中

    定义域不同

    void f1 ()
    {
     #define N 12
     const int n 12;
    }
    void f2 ()
    {
     cout<<N <<endl; //正确,N已经定义过,不受定义域限制
     cout<<n <<endl; //错误,n定义域只在f1函数中
    }

    定义后能否取消

    宏定义可以通过#undef来使之前的宏定义失效

    const常量定义后将在定义域内永久有效

    void f1()
    {
     #define N 12
     const int n = 12;
     #undef N //取消宏定义后,即使在f1函数中,N也无效了
     #define N 21//取消后可以重新定义
    }
    

    是否可以做函数参数

    宏定义不能作为参数传递给函数

    const常量可以在函数的参数列表中出现

    sunyw 9年前 (2017年06月14日)
  3. #0

    飘逸的风

    pia***[email protected]

    62

    1.const 定义常量之后,是不能够改变的

    2.宏定义是可以取消的

    定义: #define N 21
    取消: #undef N 12

    飘逸的风

    pia***[email protected]

    9年前 (2017年07月26日)
  4. #0

    123

    xuz***[email protected]

    70

    const限定符定以后是不可以改变的,所以在定义时必须赋初始值,要不然是错误的,除非这个变量是用extern修饰的外部变量。 例如:

    const int A=10; //正确。
    const int A; //错误,没有赋初始值。
    extern const int A; //正确,使用extern的外部变量。

    123

    xuz***[email protected]

    9年前 (2017年08月13日)
  5. #0

    318***[email protected]

    127

    const关键字

    constconstant的简写,只要一个变量前面用const来修饰,就意味着该变量里的数据可以被访问,不能被修改。也就是说const意味着只读(readonly)。

    规则:const离谁近,谁就不能被修改;

    const修饰一个变量,一定要给这个变量初始化值,若不初始化,后面就无法初始化。

    本质:const在谁后面谁就不可以修改,const在最前面则将其后移一位,二者等效。

    const关键字作用

    • 为给读你代码的人传达非常有用的信息,声明一个参数为常量是为了告诉用户这个参数的应用目的;
    • 通过给优化器一些附加信息,使关键字const也许能产生更紧凑的代码;
    • 合理使用关键字const可以使编译器很自然的保护那些不希望被修改的参数,防止无意的代码修改,可以减少bug的出现;

    const关键字应用

    • 欲阻止一个变量被改变,可使用const,在定义该const变量时,需先初始化,以后就没有机会改变他了;
    • 对指针而言,可以指定指针本身为const,也可以指定指针所指的数据为const,或二者同时指定为const;
    • 在一个函数声明中,const可以修饰形参表明他是一个输入参数,在函数内部不可以改变其值;
    • 对于类的成员函数,有时候必须指定其为const类型,表明其是一个常函数,不能修改类的成员变量;
    • 对于类的成员函数,有时候必须指定其返回值为const类型,以使得其返回值不为"左值"。

    318***[email protected]

    8年前 (2018年04月28日)
  6. #0

    夜月止水

    925***[email protected]

    参考地址

    226

    const char*, char const*的区别

    Bjarne 在他的 The C++ Programming Language 里面给出过一个助记的方法: 把一个声明从右向左读

    char * const cp; ( * 读成 pointer to ) 
    cp is a const pointer to char 
    const char * p; 
    p is a pointer to const char; 
    char const * p;

    同上因为 C++ 里面没有 const* 的运算符,所以 const 只能属于前面的类型。

    更多内容查看:const char*, char const*, char*const 的区别

    夜月止水

    925***[email protected]

    参考地址

    8年前 (2018年10月06日)
  7. #0

    adults

    223***[email protected]

    29

    常量实例:已知半径,求圆的周长和面积。

    #include<iostream> 
    using namespace std;
    #define PI 3.14
    int main()
    {
     float radius = 10.0;
     float area = PI * radius * radius;
     float circumference = 2 * PI * radius;
     cout << "area is "<<area <<", circumference is "<< circumference<<endl;
     return 0;
    }

    adults

    223***[email protected]

    8年前 (2018年11月01日)
  8. #0

    WXGZCC

    192***[email protected]

    45

    const 和 define 定义常量时,两个数的范围不同。

    #include<cstdio>
    using namespace std;
    const int maxn=1e+10;
    int main()
    {
     printf("%d",maxn);
     return 0;
    }

    然后输出是:

    2147483647

    如果用 define 定义的话:

    #include<cstdio>
    #define maxn 1e+10
    using namespace std;
    int main()
    {
     printf("%d",maxn);
     return 0;
    }

    输出是:

    536870912

    但是,如果将输出的 %d 改为 %lld 的话,输出为:

    4756540486875873280

    那么,可以思考一下,如果将 const 的数据也改成 longlong 的话,输出为:

    10000000000

    刚好为我们想要的那个答案。

    数据的范围还有输出的格式很重要!!!

    WXGZCC

    192***[email protected]

    8年前 (2018年11月04日)
  9. #0

    初出茅庐的攻城狮

    yan***[email protected]

    77

    预处理 #define 变量定义值以后,不能用分号,否则就会计算错误,但是程序不会报错。

    #define age 12
    #define age1 10
    #define age2 12;
    #define age3 10;
     
    int main()
    {
     int dd ; 
     dd = age + age1;
     cout << "值=" << dd << endl; //值22
     dd = age2 + age3;
     cout << "值=" << dd << endl; //值12
     return 0; 
    }
    预处理 #define 变量定义值以后,不能用分号,否则就会计算错误,但是程序不会报错。

    初出茅庐的攻城狮

    yan***[email protected]

    8年前 (2018年12月27日)
  10. #0

    smallhu

    107***[email protected]

    85

    角度1: 就定义常量说的话, const 定义的常数是变量 也带类型, #define 定义的只是个常数 不带类型。

    角度2: 就起作用的阶段而言,#define 是在编译的预处理阶段起作用,而 const 是在 编译、运行的时候起作用。

    角度3: 就起作用的方式而言,#define 只是简单的字符串替换,没有类型检查。而 const 有对应的数据类型,是要进行判断的,可以避免一些低级的错误。 正因为 define 只是简单的字符串替换会导致边界效应,具体举例可以参考下面代码:

    #define N 2+3 // 我们预想的 N 值是 5,我们这样使用 
    Ndouble a = N/2; // 我们预想的 a 的值是 2.5,可实际上 a 的值是 3.5

    角度4: 就空间占用而言, 例如:

    #define PI 3.14 //预处理后 占用代码段空间
    const float PI=3.14; // 本质上还是一个 float,占用数据段空间

    角度5: 从代码调试的方便程度而言, const 常量可以进行调试的,#define 是不能进行调试的,因为在预编译阶段就已经替换掉了

    角度6: 从是否可以再定义的角度而言, const 不足的地方,是与生俱来的,const 不能重定义,而 #define 可以通过 #undef 取消某个符号的定义,再重新定义。

    smallhu

    107***[email protected]

    7年前 (2019年03月26日)
  11. #0

    修饰指针

    修饰指针的情况比较多,主要有以下几种情况:

    1、const 修饰 *p,指向的对象只读,指针的指向可变:

    int a = 9;
    int b = 10;
    const int *p = &a;//p是一个指向int类型的const值,与int const *p等价
    *p = 11; //编译错误,指向的对象是只读的,不可通过p进行改变
    p = &b; //合法,改变了p的指向

    这里为了便于理解,可认为const修饰的是 *p,通常使用 * 对指针进行解引用来访问对象,因而,该对象是只读的。

    2、const 修饰 p,指向的对象可变,指针的指向不可变:

    int a = 9;
    int b = 10;
    int * const p = &a;//p是一个const指针
    *p = 11; //合法,
    p = &b; //编译错误,p是一个const指针,只读,不可变

    3、指针不可改变指向,指向的内容也不可变

    int a = 9;
    int b = 10;
    const int * const p = &a;//p既是一个const指针,同时也指向了int类型的const值
    *p = 11; //编译错误,指向的对象是只读的,不可通过p进行改变
    p = &b; //编译错误,p是一个const指针,只读,不可变

    看完上面几种情况之后是否会觉得混乱,并且难以记忆呢?我们使用一句话总结:

    const 放在 * 的左侧任意位置,限定了该指针指向的对象是只读的;const放在 * 的右侧,限定了指针本身是只读的,即不可变的。

    如果还不是很好理解,我们可以这样来看,去掉类型说明符,查看 const修饰的内容,上面三种情况去掉类型说明符 int 之后,如下:

    const *p; //修饰*p,指针指向的对象不可变
    * const p; //修饰p,指针不可变
    const * const p; //第一个修饰了*p,第二个修饰了p,两者都不可变

    const 右边修饰谁,就说明谁是不可变的。上面的说法仅仅是帮助理解和记忆。借助上面这种理解,就会发现以下几种等价情况:

    const int NUM = 10; //与int const NUM等价
    int a = 9;
    const int *p = &a;//与int const *p等价
    const int arr[] = {0,0,2,3,4}; //与int const arr[]等价
    6年前 (2020年08月06日)
  12. #0

    HRZGJ

    130***[email protected]

    69

    1、const 关键字出现在 * 的左边:指针指向的内容不能被修改。

    2、const 关键字出现在 * 的右边:指针本身不能被修改。

    3、const 关键字出现在 * 的两边:指针指向的内容和指针本身都不能被修改。

    #include <iostream>
    using namespace std;
    int main()
    {
     int a=1;
     int b;
     
     /**指向const的指针,指针指向的内容不能被修改**/
     const int *p1;
     int const *p2;
     
     /**const指针,指针本身不能被修改,必须初始化**/
     int *const p3=&a;
     
     /*指针本身和它指向的内容都是不能被改变的所以也得初始化*/
     const int* const p4=&a;
     int const* const p5=&b; 
     
     p1=p2=&a; //true (指针本身的值可以改变)
     *p1=*p2=8; //false(指针指向的内容不能被修改)
     
     *p3=5; //true (指针指向的内容可以改变)
     p3=p1; //false(指针本身的值不能改变) 
     
     p4=p5;//false(指针本身和它指向的内容都是不能被改变) 
     *p4=*p5=4; //false(指针本身和它指向的内容都是不能被改变) 
     
     return 0;
    }

    HRZGJ

    130***[email protected]

    5年前 (2021年03月09日)
  13. #0

    Shmily

    331***[email protected]

    29

    const 关键字出现在 * 的左边:指针指向的内容不能被修改。称其为指向常量打的指针,此时也被称为底层const

    const 关键字出现在 * 的右边:指针本身不能被修改,称其为常量指针,此时也被称为顶层const,

    const 关键字出现在 * 的两边: 指针指向的内容和指针本身都不能被修改。此时同时拥有底层和顶层const。

    几点注意:

    (1)底层指针指向的内容并非不可修改,只是无法通过该指针进行修改,换句话来说,底层指针"自作多情"地认为自己指向的内容是无法修改的,实际上可以通过赋值等方法改变其指向的内容。

    (2)在使用中,顶层const只用来修饰指针,无法修饰引用(因为引用不是变量);而底层const可以修饰指针和引用,其意义为指向或引用的内容是一个常量。只需要记住,底层const限定指向或引用的对象是常量,对指针或引用并没有限定;顶层const限定指针是常量,对其指向的内容没有限定。

    (3)底层const会给变量施加一个限制,在执行拷贝操作时,非底层const的对象无法给具有底层const的变量赋值。

    int main()
    {
     int a = 1;
     const int *p1 = &a; //底层const, 也可以用int const *p1 = &a;.
     *p1 = 2; //非法, 无法通过p1更改a的值.
     p1++; //合法, p1的值(指向的地址)是可以更改的.
     a = 2; //合法, 只是无法通过p1解引用的方式更改a的值, 其他方式可以.
     int *const p2 = &a; //顶层const, p2是常量.
     *p2 = 3; //合法, p2指向地址的内容可以更改.
     p2++; //非法, p2的值(指向的地址)无法更改.
     a = 4; //合法, p2指向地址的内容可以更改.
     const int *const p3 = &a; //同时具有底层和顶层const, p3的值(指向的地址)无法修改, 且无法通过p3解引用进行更改.
     int *p4 = p1; //非法, p1是const *int(底层const), 无法给普通int*赋值.
     int *p5 = p2; //合法, p2是*const int(顶层const), 赋值时没有限制.
     const int *p6 = p1; //合法, p6也是const *int(底层const), 可以获得p1的赋值.
    }
    

    Shmily

    331***[email protected]

    4年前 (2022年11月07日)

点我分享笔记

  • 昵称 (必填)
  • 邮箱 (必填)
  • 引用地址

AltStyle によって変換されたページ (->オリジナル) /