整数55的源码

Ⅰ c++自定义一个函数fun(char+*p),其功能是将一个数字字符串转换为一个整数

C++代码和运行结果如下：

输入num="12345"，输出fun(num)成功得到其转为的整数12345，望采纳~

附源码：

#include <iostream>

using namespace std;

int fun(char *p) {

int num = 0;

for (int i = 0; p[i] != ''; i++)

num = num * 10 + p[i] - '0';

return num;

}

int main() {

char num[10] = {0};

cin >> num;

cout << fun(num) << endl;

return 0;

}

Ⅱ 根据数组中给定的整数序列建立一个单链表，并对单链表进行升序排序，输出排序之后的单链表 求源代码急急急

以下程序把代码的前面数字去掉就可以

4 #include<stdio.h>
5 #include<stdlib.h>
6 typedef struct node //节点声明
7 {
8 int Data;
9 struct node* Next;
10 }Node;
11
12 typedef Node* PNode; //将节点Node* 用PNode代替
13
14 typedef struct //链表LinkList的定义
15 {
16 PNode Head;
17 PNode Tail;
18 int Size;
19 }LinkList;
3 void CreateList(LinkList *ls) //链表初始化
4 {
5 ls->Head = NULL;
6 ls->Tail = NULL;
7 ls->Size = 0;
8 }
10 int AppendNode(LinkList *ls, int Data) //增加链表节点
11 {
12 PNode newnode;
13 newnode = (PNode)malloc(sizeof(Node));
14 newnode->Data = Data;
15 newnode->Next = NULL;
16 if(ls->Head == NULL)
17 {
18 ls->Head = newnode;
19 ls->Tail = newnode;
20 }
21 else
22 {
23 ls->Tail->Next = newnode;
24 ls->Tail = newnode;
25 }
26 ls->Size++;
27 }
30 void DestroyList(LinkList *ls) //释放链表
31 {
32 PNode tmpnode = ls->Head;
33 while(tmpnode)
34 {
35 tmpnode = tmpnode->Next;
36 free(ls->Head);
37 ls->Head = tmpnode;
38 }
39 ls->Head = NULL;
40 ls->Tail = NULL;
41 ls->Size = 0;
42 }
44 void PrintList(LinkList *ls) //打印链表
45 {
46 PNode tmpnode;
47 int i=0;
48 tmpnode = ls->Head;
49 printf("\t\t");
50 while(tmpnode != NULL)
51 {
52 if(i%5 == 0)
53 {
54 putchar('\n');
55 printf("\t\t");
56 }
57 printf("\t%-d",tmpnode->Data);
58 tmpnode = tmpnode->Next;
59 i++;
60 }
61 putchar('\n');
62 }
140 int SortNode(LinkList *ls) //根据节点中的数据Data，升序排序
141 {
142 PNode tmpnode,endnode,newnode;
143 int tmp;
144 endnode = ls->Tail;
145 while(endnode != ls->Head)
146 {
147 tmpnode = ls->Head;
148 while(tmpnode != endnode)
149 {
150 if(tmpnode->Data > tmpnode->Next->Data)
151 {
152 tmp = tmpnode->Data;
153 tmpnode->Data = tmpnode->Next->Data;
154 tmpnode->Next->Data = tmp;
155 }
156 newnode = tmpnode;
157 tmpnode = tmpnode->Next;
158 }
159 endnode = newnode;
160 }
161 return 0;
162 }

2 int main() //主函数
3 {
4 LinkList ls;
5 int i,n,k,p;
6 CreateList(&ls);
7 srand(time(NULL)); //产生随机数的种子
8 for(i=0;i<20;i++)
9 {
10 AppendNode(&ls,rand()%100); //生成节点，节点的Data数据为0~99的随机数
11 }
12 printf("输出一个随机链表：\n");
13 PrintList(&ls);
14 putchar('\n');
30 printf("经过排序后的链表为：\n");
31 SortNode(&ls);
32 PrintList(&ls);
36 DestroyList(&ls);
37 }

Ⅲ 小数和分数的原码&补码怎么做啊

一、小数部分的原码和补码可以表示为两个复数的分子和分母，然后计算二进制小数系统，根据下面三步的方法就会找出小数源代码和补码的百位形式。

37／64＝100101B／2＾6＝0．100101B

－51／128＝110011B／2＾7＝0．0110011B

二、将十进制十进制原始码和补码转换成二进制十进制，然后根据下面三步的方法求出十进制源代码和补码形式。一个

0．375＝0．011B

0．5625＝0．1001B

三、二进制十进制对应的原码和补码

［37／64］源代码＝［0．100101B］源代码＝00100101B

［－51／128］源代码＝［0．0110011b］源代码＝10110011B

［0．375］原码＝［0．011b］原码＝00110000B

［0．5625］源代码＝［0．1001B］源代码＝01001000B

［37／64］补体＝［0．100101B］补体＝00100101B

［－51／128］补体＝［0．0110011b］补体＝11001101B

［0．375］补码＝［0．011b］补码＝00110000B

［0．5625］补体＝［0．1001B］补体＝01001000B

(3)整数55的源码扩展阅读：

原码、逆码、补码的使用：

在计算机中对数字编码有三种方法，对于正数，这三种方法返回的结果是相同的。

＋1＝00000001［原码］＝00000001［逆码］＝00000001［补码］

对于这个负数：

对计算机来说，加、减、乘、除是最基本的运算。有必要使设计尽可能简单。如果计算机能够区分符号位，那么计算机的基本电路设计就会变得更加复杂。

负的正数等于正的负数，2－1等于2＋（－1）所以这个机器只做加法，不做减法。符号位参与运算，只保留加法运算。

（1）原始代码操作：

十进制操作：1－1＝0。

1－1＝1＋（－1）＝00000001［源代码］＋10000001［源代码］＝10000010［源代码］＝－2。

如果用原代码来表示，让符号位也参与计算，对于减法，结果显然是不正确的，所以计算机不使用原代码来表示一个数字。

（2）逆码运算：

为了解决原码相减的问题，引入了逆码。

十进制操作：1－1＝0。

1－1＝1＋（－1）＝00000001［源代码］＋10000001［源代码］＝00000001［源代码］＋11111110［源代码］＝11111111［源代码］＝10000010［源代码］＝－0。

使用反减法，结果的真值部分是正确的，但在特定的值“0”。虽然＋0和－0在某种意义上是相同的，但是0加上符号是没有意义的，00000001［源代码］和10000001［源代码］都代表0。

（3）补充操作：

补语的出现解决了零和两个码的符号问题。

十进制运算：1－1＝0。

1－1＝1＋（－1）＝00000001［原码］＋10000001［原码］＝00000001［补码］＋11111111［补码］＝00000000［补码］＝00000000［原码］＝0。

这样，0表示为［00000000］，而之前的－0问题不存在，可以表示为［10000000］－128。

（－1）＋（－127）＝10000001［源代码］＋11111111［源代码］＝11111111［补充］＋10000001［补充］＝1000000［补充］＝－128。

－1－127的结果应该是－128。在补码操作的结果中，10000000［补码］是－128，但是请注意，由于－0的补码实际上是用来表示－128的，所以－128没有原码和逆码。（－128的补码表10000000［补码］计算出的00000000［原码］是不正确的）。

Ⅳ 易语言 数字相加

你写5522是55和22相加还是5和522相加,还是。。？几个数字之间肯定要符号间隔开的，比如55,22这样就是55和22相加，如果是整数相加请把结果的类型改为整数型。
给你个源码吧：
.版本 2
.支持库 spec

.子程序 _按钮1_被单击
.局部变量 数字数组, 文本型, , "0"
.局部变量 计次, 整数型
.局部变量 结果, 小数型

数字数组 ＝ 分割文本 (编辑框1.内容, “,”, ) ' 以英文逗号间隔数字
.计次循环首 (取数组成员数 (数字数组), 计次)
结果 ＝ 结果 ＋ 到数值 (数字数组 [计次])
.计次循环尾 ()
调试输出 (结果)
是否可以解决您的问题？

Ⅳ 假定某台计算机的机器数占8位计算出有符号十进制数-55的源码,反码和补码

因为是8位，所以在符号位和数值位间加一个0

Ⅵ 给下列16进制数，若将此数分别视为无符号数，源码，补码，反码和移码表示，写出对应的十进制整数

50H = 0101 0000B

50H 当做无符号数字，代表：80。
50H 当做原码，代表：80。
50H 当做反码，代表：80。
50H 当做补码，代表：80。
50H 当做移码，代表：－48。

FEH = 1111 1110B

FEH 当做无符号数字，代表：254。
FEH 当做原码，代表：－126。
FEH 当做反码，代表：－1。
FEH 当做补码，代表：－2。
FEH 当做移码，代表：+126。

Ⅶ C语言程序

#include<stdio.h>

#include<math.h>

intmain(){

inti,x,max = -1,a[16],temp;

floatave=0.0;

a[0]=55;

for(i=1;i<16;i++)

a[i]=(15*a[i-1]+97)%256;

for(i=0;i<16;i++){

printf("%d",a[i]);

ave+=(float)a[i];

}

ave/=16.0;

printf(" ave=%.1f",ave);

for(i=0;i<16;i++){

temp= abs(a[i]-ave);

if(temp>max){

max=temp;

x=i;

}

}

printf("差最大的数:%d ",a[x]);

for(i=0,max=0;i<16;i++,max++){

if(i==x)max++;

a[i]=a[max];

}

for(i=0;i<15;i++)

printf("%d",a[i]);

return0;

}

//效果也一样

Ⅷ 整理一下关于原码反码补码笔记

一个数据表示时使用，第一位为符号位，剩余的为有效位

字16位 1位符号 15有效数据位

int>整数 4个字节32

-2 ^31-2 32-1

long>长整形8个字节64一位符号63

-2 ^63-2 63-1

1000 0111 （-7）二转十

机器数
机器数就是一个数在计算机中二进制表现形式
+3 0000 0011
+7 0000 0111
-5 1000 0101

机器数的真值
将带符号位的机器数对应的真正数值称为机器数的真值
0000 0011 = +3
0000 0111 = +7
1000 0101 = -5

原码就是符号位加上真值的绝对值

求原码：

34=00100010

原码 -39 1 0 1 0 0 1 1 1

原码 -55 1 0 1 1 0 1 1 1

正数：正数的反码=源码 如 +9：0000 1001 源码=0000 1001 反

负数：符号位不变，其余各位琢一取反，只有两种状态{0,1}，即1->0 0->1

负数
负数的反码是保持符号位不变,其余各位直接取反
取反: 只有0 和 1两种状态,也就是 0 -> 1 , 1 -> 0
-3 1000 0011[原] = 1111 1100[反]

正数：正数的原码=反码=补码 如+3 0000 0011 {原}=0000 0011{反}=0000 0011 {补}

负数：先求的反码，在负数反码的基础上，加一

补码需要在反码的基础上转换得到
正数
正数的原码 反码 补码 全部相同
+1 0000 0001[原] = 0000 0001[反] = 0000 0001[补]

负数
负数的补码需要在反码的基础上,最后一位加 1;
-3 1111 1100[反] = 1111 1101[补

扩展

为什么需要反码和补码？

在设计计算机时，只设计了加法器没有设计减法器

5-3=5+（-3）

原码

5=0000 0101 （原码）

-3=1000 0011 （原码）

0000 0101

1000 0011

1000 1000 结果（原码）=-8

原码不可以直接计算的!

反码：解决了只设计加法器，使用加法器进行减法运算的问题；

缺点:正负相加0的表示不唯一

1-1=1+（-1）

1=0000 0001 {反}

-1=1000 0001 {原码}

-1=1111 1110 {反码}

0000 0001

1111 1110

1111 1111 {反码}=1000 0000{原码}=-0 负0

补码{高位溢出}

1=0000 0001{补}

-1=1111 1111{补}

0000 0001

1111 1111

0000 0000

一个字节8位，表达的范围-2 ^7-2 7-1

32+12=44

44-12=32

44+（-12）=32

将补码转原码

因为负数的补码不能直接读出结果，但是原码可以，所以将补码转原码，可以读出负数的值

补码>原码

原则：==补码的补码

把补码当原码，求补码

计算规则：符号位不变，其余取反，加1；

ASCll编码：最早的最重要的基本的英美文字的字符集

只使用了低7位二进制，其他的认为无效，它使用了0-127这128个码位。剩下128个码位留作扩展，采用顺序存储方式存储字符

ISO-8859-*

使用ASCll 剩余的码位进行扩展

iso-8859-1专门对英语做的扩展 tomcat>默认采用iso-8859-1》utf-8

西欧国家较多，各个国家在ASCll基础上，扩展形成了自己国家专用的编码，最终形成了ISO-8859-*系列

GB2312

GB2312字集是简体，6763个简体汉字

BIG5

繁体字集

Unicode

字符集（简称为UCS）

GBK【936】

是简繁字集，包括GB2312字集，BlG5字集合一些符号，共包括21003个字符。GBK编码是GB2312的超级，向下完全兼容GB2312

UTF-8[65001]万国码

包含全世界所有国家需要用到的字符，是国际编码，它对英文使用8位（即一个字节），中午使用3个字节

ANSl

ANSl不是一种具体的编码

系统默认的编码决定，如果系统的默认的编码是GBK> ANSl就代表 GBK

认识ASCll码表

常用：0-9 A-Z a-z对应的ASCll码分别为：48-57,65-90,97-122

0>48

A>65

a>97

Ⅸ 求C++源代码 已知四位数如3025，有一个特殊性质: 它的前两位数字30和后两位数字25的和是5

for(inti=1000;i<10000;i++)
{
intleft=i/100;
intright=i%100;
if((left+right)*(left+right)==i)
{
printf("%d",i);
}
}

Ⅹ 一个数的原码，反码，补码怎么算

计算机中的存储系统都是用2进制储存的,对我们输入的每一个信息它都会自动转变成二进制的形式,而二进制在存储的时候就会用到原码,反码和补码例如:输入25原码是:0000000000011001反码: 1111111111100110 补码: 1111111111100111

数值在计算机中表示形式为机器数,计算机只能识别0和1,使用的是二进制,而在日常生活中人们使用的是十进制,"正如亚里士多德早就指出的那样,今天十进制的广泛采用,只不过我们绝大多数人生来具有10个手指头这个解剖学事实的结果.尽管在历史上手指计数(5,10进制)的实践要比二或三进制计数出现的晚. "(摘自<<数学发展史>>有空大家可以看看哦~,很有意思的).为了能方便的与二进制转换,就使用了十六进制(2 4)和八进制(23).下面进入正题.

数值有正负之分,计算机就用一个数的最高位存放符号(0为正,1为负).这就是机器数的原码了.假设机器能处理的位数为8.即字长为1byte,原码能表示数值的范围为

(-127~-0 +0~127)共256个.

有了数值的表示方法就可以对数进行算术运算.但是很快就发现用带符号位的原码进行乘除运算时结果正确,而在加减运算的时候就出现了问题,如下: 假设字长为8bits

( 1 ) 10- ( 1 )10 = ( 1 )10 + ( -1 )10 = ( 0 )10

(00000001)原 + (10000001)原 = (10000010)原 = ( -2 ) 显然不正确.

因为在两个整数的加法运算中是没有问题的,于是就发现问题出现在带符号位的负数身上,对除符号位外的其余各位逐位取反就产生了反码.反码的取值空间和原码相同且一一对应. 下面是反码的减法运算:

( 1 )10 - ( 1 ) 10= ( 1 ) 10+ ( -1 ) 10= ( 0 )10

(00000001) 反+ (11111110)反 = (11111111)反 = ( -0 ) 有问题.

( 1 )10 - ( 2)10 = ( 1 )10 + ( -2 )10 = ( -1 )10

(00000001) 反+ (11111101)反 = (11111110)反 = ( -1 ) 正确

问题出现在(+0)和(-0)上,在人们的计算概念中零是没有正负之分的.(印度人首先将零作为标记并放入运算之中,包含有零号的印度数学和十进制计数对人类文明的贡献极大).

于是就引入了补码概念. 负数的补码就是对反码加一,而正数不变,正数的原码反码补码是一样的.在补码中用(-128)代替了(-0),所以补码的表示范围为:

(-128~0~127)共256个.

注意:(-128)没有相对应的原码和反码, (-128) = (10000000) 补码的加减运算如下:

( 1 ) 10- ( 1 ) 10= ( 1 )10 + ( -1 )10 = ( 0 )10

(00000001)补 + (11111111)补 = (00000000)补 = ( 0 ) 正确

( 1 ) 10- ( 2) 10= ( 1 )10 + ( -2 )10 = ( -1 )10

(00000001) 补+ (11111110) 补= (11111111)补 = ( -1 ) 正确

所以补码的设计目的是:

⑴使符号位能与有效值部分一起参加运算,从而简化运算规则.

⑵使减法运算转换为加法运算,进一步简化计算机中运算器的线路设计

所有这些转换都是在计算机的最底层进行的，而在我们使用的汇编、C等其他高级语言中使用的都是原码