c语言里const int 和int 有啥区别,const的作用是啥。

Posted 2023-05-18

一、const int 和int 的区别

1、返回值

const int & 是返回这个数值的一个常量的引用。

而int 是返回这个数值的一个拷贝。

int 是进行拷贝构造，而const int & 是返回的引用。拷贝构造更消耗时间，与此同时还用析构函数。因为产生了一个拷贝，你就可以轻易地修改拷贝的内容。

2、取指针

const int类型一旦定义以后就不能修改，int类型是随时可以修改的。

在取指针方面，const有略复杂的东西，但是常规的、合理的操作不应该涉及到，因为const int是用来保存一些全局常量的，这些常量在编译期可以改，在运行期不能改。

听起来这像宏，其实这确实就是用来取代宏的： #define PI 3.14 const float Pi = 3.14; 如果你的代码里用到了100次PI（宏），你的代码中会保存100个3.14这个常数。

鉴于使用常数进行运算的机器代码很多时候会比使用变量来的长，如果你换用100次Pi（const float)，程序编译后的机器码里就不需要出现100次常量3.14，只要在需要的时候引用存有3.14的常量就行了。

特别在复杂的运算里，3.14这个常量（其实是无法修改的变量）会被一直装载在寄存器里带来一些性能提升。

3、内容

constint* p; //p可变，p指向的内容不可变，int const* p; //p可变，p指向的内容不可变。 int* const p; //p不可变，p指向的内容可变 const int* const p; //p和p指向的内容都不可变。

二、const的作用：

1、可以定义const常量，具有不可变性。 

例如：const int Max=100; Max++会产生错误; 

2、便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。

例如： void f(const int i) ......... 编译器就会知道i是一个常量，不允许修改； 

3、可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 同宏定义一样，可以做到不变则已，一变都变！

如1中，如果想修改Max的内容，只需要它修改成：const int Max=you want;即可！

4、可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 

例如： void f(const int i) i=10;//error!  

5、可以节省空间，避免不必要的内存分配。

扩展资料

当const修饰的是指针类型，那么指针的值就不能改变，即不能指向其他地址，但是可以通过指针修改其指向地址里面的值。

当const修饰时指针指向的类型时候，那么指针被指向其他地址，但是不能通过指针修改指针里面的值。

1）先从const int i说起。

使用const修饰的i我们称之为符号常量。即，i不能在其他地方被重新赋值了。注意：const int i与int const i是等价的，相同的，即const与int的位置无所谓。

2）const int *p

看例子：

int i1=30;

int i2=40;

const int *p=&i1;

p=&i2;  //此处，p可以在任何时候重新赋值一个新的内存地址。

i2=80;  //这里能用*p=80来代替吗？答案是不能

printf("%d",*p);  //输出80

分析：p的值是可以被修改的，即它可以重新指向另一个地址。但是不能通过*p来修改i2的值。

首先，const修饰的是整个*p(注意，是*p而不是p)，所以*p是常量，是不能被赋值的。虽然p所指的i2是变量而不是常量；

其次，p前并没有用const修饰，所以p是指针变量。能被赋值重新指向另一个内存地址。

参考资料：百度百科——const

参考技术A

一、区别如下：

1、int定义的量是变量，它的值可以更改；而const int 定义的是一个常量，它的值不可以更改。

2、int在定义的时候，不需要初始化，而const int 在定义的时候必须初始化；

二、const的作用：把对象转换成一个常量

拓展资料

const与define。两者都可以用来定义常量，但是const定义时，定义了常量的类型，所以更精确一些。#define只是简单的文本替换，除了可以定义常量外，还可以用来定义一些简单的函数，有点类似内联函数(Inline)。const和define定义的常量可以放在头文件里面。

参考资料：百度百科：CONST

参考技术B

1、内容不同

constint* p; //p可变，p指向的内容不可变，int const* p; //p可变，p指向的内容不可变。 int* const p; //p不可变，p指向的内容可变 const int* const p; //p和p指向的内容都不可变。

2、取指针

const int类型一旦定义以后就不能修改，int类型是随时可以修改的。

3、返回值

const int是返回这个数值的一个常量的引用。

而int是返回这个数值的一个拷贝。

const作用：

1、可以定义const常量，具有不可变性。

例如：const int Max=100; Max++会产生错误。

2、便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。

例如： void f(const int i) ......... 编译器就会知道i是一个常量，不允许修改。

3、可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。

扩展资料：

const 和指针一起使用会有几种不同的顺序，如下所示：

1、const int *p1;

2、int const *p2;

3、int * const p3;

在最后一种情况下，指针是只读的，也就是 p3 本身的值不能被修改；在前面两种情况下，指针所指向的数据是只读的，也就是 p1、p2 本身的值可以修改（指向不同的数据），但它们指向的数据不能被修改。

当然，指针本身和它指向的数据都有可能是只读的，下面的两种写法能够做到这一点：

1、const int * const p4;

2、int const * const p5;

参考技术C 怎么会有人说没有区别的。。没区别还要这个东西干蛋。。
在取指针方面，const有略复杂的东西，但是常规的、合理的操作不应该涉及到，因为const int是用来保存一些全局常量的，这些常量在编译期可以改，在运行期不能改，听起来这像宏，其实这确实就是用来取代宏的：
#define PI 3.14
const float Pi = 3.14;
如果你的代码里用到了100次PI（宏），你的代码中会保存100个3.14这个常数，鉴于使用常数进行运算的机器代码很多时候会比使用变量来的长，如果你换用100次Pi（const float)，程序编译后的机器码里就不需要出现100次常量3.14，只要在需要的时候引用存有3.14的常量就行了，特别在复杂的运算里，3.14这个常量（其实是无法修改的变量）会被一直装载在寄存器里带来一些性能提升。
清楚了const的用法，const int和int的区别就很简单，int i里的i可以被更改，是真正的变量，const int i的i不可以被更改，是有着变量外衣的常数。本回答被提问者和网友采纳 参考技术D 两个没有区别，但当const修饰的是指针时就有区别.
const int* a
int* const a ;
如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量

C中的“short int”和“int”有啥区别？

【中文标题】C中的“short int”和“int”有啥区别？

【英文标题】：What is the difference between "short int" and "int" in C?C中的“short int”和“int”有什么区别？

【发布时间】：2012-08-30 00:46:54

【问题描述】：

C 中的 short int（或 short）和 int 有何不同？它们具有相同的大小和范围。如果它们本质上相同，那么拥有两种数据类型有什么用？

【问题讨论】：

在 16 位编译器中，它们具有相同的大小和范围。几乎所有主流平台的现代编译器都有sizeof(int) > sizeof(short)。

【参考方案1】：

它们可能具有相同的大小，但保证int 等于或大于short int。

【讨论】：

真正保证的是short int的范围至少是-32767 .. +32767，short int的范围是范围的子集int。由此可知short int 和int 都至少是16 位。由于填充位，理论上可以有sizeof (short int) > sizeof (int)，但可能性很小。

@KeithThompson 你能详细说明sizeof (short int) > sizeof (int) 吗？

@icepack：整数类型可以有填充位，这些位对值没有贡献。例如，符合要求的实现理论上可以有 32 位（其中 16 个填充位）的 short 和 24 位（全部有效）的int。我想不出有什么理由去做这种傻事，但标准并没有禁止。

【参考方案2】：

"一种编程语言中的短整数可能有不同的大小 使用不同的语言或在不同的处理器上。在某些语言中 这个大小在平台上是固定的，而在其他平台上是 机器相关。在某些语言中，此数据类型不存在于 全部。”

Source

【讨论】：

但问题是关于 C.

是的，发布的源链接显示了 C、C++、C# 和 Java 的区别。

您引用的部分没有回答问题。 （顺便说一句，该段后来从文章中删除。）

【参考方案3】：

这取决于系统。某些操作系统的两种类型的长度不同。

【参考方案4】：

永远不要依赖 C 中给定大小的数据类型。如有疑问，请始终检查 limits.h 中的边界。

【讨论】：

当然，如果您使用的是uint32_t 和来自<stdint.h> 的朋友。

这是 C99 标准的一部分，它让我们回到其他人提出的关于使用什么操作系统/编译器的问题。

【参考方案5】：

实际上一切都取决于编译器和系统。但基本规则是 int 永远不能小于 short，也永远不能大于 long。

短

【讨论】：

char ISO C90

不支持 long long

【参考方案6】：

理论上/按照 C 标准，它们可以是任意大小，只要 16 bit <= short <= int。

在现实世界中，这就是尺寸的实现方式。

CPU             short   int
8 bit           16      16
16 bit          16      16
32 bit          16      32
64 bit          16      32

【讨论】：

你有没有在 64 位的 linux 中的 ansi c 和 64 位的 windows 中的 Visual Studio 中检查它我只是想知道..

@BharatSharma 64 位仅对long 和long long 的大小有影响。显然，一些 64 位系统将 long 定义为 64 位，而其他系统实现 C99/C11 标准并将long long 用于 64 位，而将long 保留为 32 位。

谢谢，一旦我发现与 long 相关的问题，所以我想这也可能是 short... :)

它们不能是任何尺寸；两者都必须至少为 16 位。顺便说一句，我曾在 32 位 (Cray T3E) 和 64 位 (Cray T90) short 的系统上工作过。

@Lundin 那么在 64 位拱门中，int 与 long 相同（都是 32 位），这是真的吗？

【参考方案7】：

C99 N1256 standard draft

我们现在可以肯定的是：

2 <= sizeof(short) <= sizeof(int)

5.2.4.2.1 整数类型的大小<limits.h> 给出了最小大小：

1 [...] 它们的实现定义值的大小（绝对值）应等于或大于所示值 [...]

UCHAR_MAX 255 // 2 8 - 1 USHRT_MAX 65535 // 2 16 - 1 UINT_MAX 65535 // 2 16 - 1 ULONG_MAX 4294967295 // 2 32 - 1 ULLONG_MAX 18446744073709551615 // 2 64 - 1

6.2.5 类型 然后说：

8 对于任意两个具有相同符号和不同整数转换等级的整数类型 （见 6.3.1.1），整数转换等级较小的类型的取值范围是 其他类型值的子范围。

和6.3.1.1 布尔、字符和整数确定相对转换等级：

1 每个整数类型都有一个整数转换等级，定义如下：

long long int 的秩应大于 long int 的秩，即 应该大于int的rank，int的rank应该大于short的rank int，应大于signed char的等级。 任何无符号整数类型的等级应等于相应的等级 有符号整数类型（如果有）。 对于所有整数类型 T1、T2 和 T3，如果 T1 的秩大于 T2 并且 T2 具有 排名大于 T3，则 T1 排名大于 T3

【参考方案8】：

我今天也在做同样的事情。我的结论是它取决于执行程序的机器架构的字长。 根据 C99 limits.h 文档。

/* Minimum and maximum values a `signed short int' can hold.  */
#  define SHRT_MIN  (-32768)
#  define SHRT_MAX  32767

/* Maximum value an `unsigned short int' can hold.  (Minimum is 0.)  */
#  define USHRT_MAX 65535

/* Minimum and maximum values a `signed int' can hold.  */
#  define INT_MIN   (-INT_MAX - 1)
#  define INT_MAX   2147483647

/* Maximum value an `unsigned int' can hold.  (Minimum is 0.)  */
#  define UINT_MAX  4294967295U

/* Minimum and maximum values a `signed long int' can hold.  */
#  if __WORDSIZE == 64
#   define LONG_MAX 9223372036854775807L
#  else
#   define LONG_MAX 2147483647L
#  endif
#  define LONG_MIN  (-LONG_MAX - 1L)

/* Maximum value an `unsigned long int' can hold.  (Minimum is 0.)  */
#  if __WORDSIZE == 64
#   define ULONG_MAX    18446744073709551615UL
#  else
#   define ULONG_MAX    4294967295UL
#  endif

如果有人有更好的答案，请告诉我。

【讨论】：

只是添加试试这个

短整数 i = 2147483647; printf("%d %d %d\n",i, i+1,i+10);

int i = 2147483647; printf("%d %d %d\n",i, i+1,i+10);

我在 64 位机器上工作，测试人员观察翻转问题是很好的观察

【参考方案9】：

short 和 int 必须至少为 16 位，long 必须至少为 32 位，并且该 short 不长于 int，即不长于 long。通常，short 是 16 位，long 是 32 位，int 是 16 位或 32 位。

【参考方案10】：

这取决于编译器。 在某些编译器中，int 是 2 个字节，而在其他编译器中是 4 个字节。

【讨论】：

感谢您的贡献 - 但是这个答案提供了其他 11 个答案中尚未说明的内容？