IOS-C_Day2___进制编码

2015.1.20

//十进制

//0 1 2 3 4 5 6 7 8 9 10 11 12 .... 99 100 101 ...

//进位: "逢十进一"

//二进制(对于计算机是最自然的语言)

//0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111

//"逢2进1"

//高电平: 1 低电平 0

//5+6

//机器语言

//0101001010101010

//0101001010101001

//1010101010100110

//汇编语言

//5+6

//movl $5 %-8(rbp)

//movl $6 %-12(rbp)

//movl %-8(rbp) %eax

//addl %-12(rbp) %eax

//movl %eax %esi

//可移植性差

//5+6 c99

//int a = 5;

//int b = 6;

//int c = a+b;

//简洁 , 可移植性强, 健壮性

//编译器:C语言 -- >  汇编语言 --> 二进制语言

//OC语言 --> C语言 --> 汇编语言 --> 二进制语言

//123 = 1*10^2 + 2*10^1 + 3*10^0

//除10倒序取余数

//123  / 10 -- 3

//12   / 10 -- 2

//1    / 10 -- 1

//123

//十进制转二进制

//除2倒序取余数

//123

//123 / 2 -- 1

//61  / 2 -- 1

//30  / 2 -- 0

//15  / 2 -- 1

//7   / 2 -- 1

//3   / 2 -- 1

//1   / 2 -- 1

//0   / 2 -- 0

//0

//123 = 0b1111011 = 1 *2^0 + 1*2^1 + 0*2^2 + 1*2^3 + 1*2^4 + 1*2^5 + 1*2^6 = 1 + 2 + 0 + 8 + 16 + 32 + 64 = 123

//表示二进制数在数据的前面加0b  0b1010101001 0b11111

//345 678 987

/*int main(int argc,const char *argv[])

{

int bin[32]={};

int num;

scanf("%d", &num);//小写键盘Enter键不能使用

//%d  整型数据格式化占位符

int i=0;

while (num) {//num = 0

bin[i]= num%2;

num/=2;//改变num的值

i++;

}

printf("0b");

for (i=i-1; i>=0 ; i--) {

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

}

printf("\n");

return 0;

}*/

//八进制

//0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20 ...

//逢8进1

//八进制在前面加0表示八进制数

//010

//数据的大小不因为进制的表现形式而改变

//int main(int argc, const char *argv[])

//{

//    int a = 10;

//    int b = 0b1010;

//    int c = 012;

//    int d = 0xa;

//

//    printf("a = %d b = %d c = %d d = %d\n", a, b, c, d);

//

//    return 0;

//}

//十进制数转八进制数

//除8倒序取余数

//123

//123  / 8 --- 3

//15   / 8 --- 7

//1    / 8 --- 1

//0

//123 = 0173 = 3*8^0 + 7*8^1 + 1*8^2 =  3 + 56 + 64 = 123

//233 156 78

//int main(int argc,const char *argv[])

//{

//    int num ;

//    scanf("%d", &num);

//    printf("0%o\n", num);//%o 八进制数占位符

//    return 0;

//}

//八进制转二进制

//"421"

// 0     1     2      3      4      5       6      7

//000   001   010     011    100    101     110    111

//0173 = 0b1111011

//把八进制数中每一位, 分别用三位二进制数替换

//04567    0765   01234

//0b100 101 110 111

//0b111 110 101

//0b001 010 011 100

//二进制数转八进制数

//0b 011 110 001 101 011 110 000 110

//036153606

//从低位开始, 每三位为一组, 高位不足三位补0, 用八进制数替换三位二进制数

//十六进制

//逢十六进一

//0 1 2 3 4 5 6 7 8 9 a/A b/B c/C d/D e/E f/F

//10 11 12 13 .... 1f ...20 ...ff ...100 ...101

//前缀0x说明一个十六进制数 0x100

//十进制数转十六进制数

//除十六倒序取余数

//123

//123  / 16 -- b

//7    / 16 -- 7

//0

//123 = 0x7b = b*16^0 + 7*16^1 = 11+112 = 123;

//十六进制转二进制

//分别用4位二进制数替换每一位十六进制数

//"8421"

//0      1    2     3     4    5     6     7     8

//0000 0001 0010   0011  0100  0101  0110  0111  1000

//9      a       b      c     d     e      f

//1001   1010   1011   1100   1101  1110  1111

//0x2345678 = 0b10001101000101011001111000

//0xfeabc9876543210 = 0b1111 1110 1010 1011 1100 1001 1000 0111 0110 0101 0100 0011 0010 0001 0000

//二进制转十六进制

//从低位开始, 每四位为一组, 高位不足四位补0, 分别用十六进制数替换四位二进制数

//0b0101 1101 0110 1010 1111 0001 1110 1100

//0x5d6af1ec

//对于一个很大的数转换成二进制,用八进制或者十六进制进行过度

//345678908765

//计算机中的单位

//计算机中最小的单位是二进制位 1bit

//八个二进制位 组成一个字节 1Byte = 8bits

//1Kb = 1024Bytes

//1Mb = 1024Kb

//1Gb = 1024Mb

//1Tb = 1024Gb

//1Pb = 1024Tb

//硬盘厂商

//500Gb = 500*1000Mb = 500 * 1000Mb *1000Kb = 500 *1000Mb *1000Kb *1000Byte

//int main(int argc, const char * argv[]) {

//

//

//    printf("hello world\n");

//

//    return 0;

//}

//数据在计算机中存储形式

//内存: RAM ROM

//由二进制位电路组成

//数据编码方式

//以8bits为例   char

//以最高位作为符号位, 其余位表示数据的大小

//最高位为1 说明是一个负数, 最高位为0 说明是一个正数

//原码: 最高位为符号位, 其余位表示数据的绝对值大小

//-6 1000 0110

//6+5

//    00000110  6

//    00000101  5

//-------------------

//    00001011 = 11

//6+(-5)

//    0000 0110

//    1000 0101

//-----------------

//    1000 1011(原码) = -11

//原码不能进行减法运算, 原因是符号位也参与了运算

//反码: 正数的反码就是它的原码, 负数的反码,是在原码的基础上,符号位不变,其余位按位取反

//7 原码: 0000 0111 反码: 0000 0111

//-7  原码: 1000 0111 反码: 1111 1000

//-5 原码: 1000 0101 反码; 1111 1010

//-9 原码: 1000 1001 反码: 1111 0110

//-12 原码: 1000 1100   反码: 1111 0011

//6+(-5)

//    0000 0110

//  + 1111 1010

//----------------

//    0000 0000(反码) = 0

//-5+(-6)

//    1111 1010

//+   1111 1001

//-----------------

//    1111 0011(反码) ==> 1000 1100  ==> -12

//反码转原码: 再求一次反码

//0 的表示不唯一

//+0  0000 0000

//-0  1000 0000

//反码不能存储数据的原因就是0的表示不唯一

//补码: 正数的补码就是它的原码 负数的补码,是在反码的基础上加1

//6 : 0000 0110(补码)

//-6 : 1000 0110 --> 1111 1001 --> 1111 1010(补码)

//-5 : 1000 0101 --> 1111 1010 --> 1111 1011(补码)

// -6 + (-5)

//   1111 1010

//   1111 1011

//---------------

//   1111 0101(补码) --> 1000 1010 --> 1000 1011(原码) = -11

//补码转原码: 正数不变, 对于负数, 符号位不变, 其余位按位取反加1

//计算机中采用补码的方式存储数据

//-12 原码: 1000 1100 反码: 1111 0011 补码: 1111 0100

//-34 原码: 1010 0010 反码: 1101 1101 补码: 1101 1110

//-128 原码: 11000 0000  反码: 10111 1111 补码: 1000 0000

//规定: 1后面跟7个0就是当前范围内最小的数  1即表示符号位,又表示绝对值大小

//-127 原码: 1111 1111  反码: 1000 0000 补码: 1000 0001

//-0 原码: 1000 0000 反码: 1111 1111 补码: 0000 0000

//+0 0000 0000

//-128 ~~~ 127

//0x80 ~~ 0x7f

//16二进制位

//1000 0000 0000 0000   ~~~ 0111 1111 1111 1111

//0x8000  ~~~ 0x7fff

//数据类型

//整型

//有符号

//64位平台

//char     short      int       long       long long

//1byte    2bytes    4bytes     8bytes     8bytes

//32位平台

//1byte    2bytes     4bytes     4bytes    8bytes

//无符号

//unsigned char 0x00 ~~~ 0xff

//unsigned int   0x00000000 ~~~ 0xffffffff

//unsigned short  0x0000 ~~~ 0xffff

//unsigned long   0x0000000000000000 ~~~ 0xffffffffffffffff

//unsigned long long 0x0000000000000000 ~~~ 0xffffffffffffffff

/*int main(int argc, const char *argv[])

{

//int a;

printf("char = %lu\n", sizeof(char));//sizeof运算符 求数据类型,或者变量占用内存空间大小

//    char a= 0x80, b = 0x7f;

//    printf("char %d ~~~ %d\n", a, b);

printf("unsigned char = %ld\n", sizeof(unsigned char));

//0 ~~ 255

//    unsigned char a= 0x00, b = 0xff;

//    printf("char %d ~~~ %d\n", a, b);

//    short a =0x8000, b = 0x7fff;

//    printf("short  %d ~~~ %d\n", a, b);

//    printf("short = %lu\n", sizeof(short));

//    int a = 0x80000000, b = 0x7fffffff;

// printf("int %d ~~~ %d\n", a, b);

printf("int = %lu\n", sizeof(int));

long a= 0x8000000000000000, b= 0x7fffffffffffffff;

printf("long %ld ~~~ %ld\n" , a, b);

printf("long = %lu\n", sizeof(long));

printf("long long = %lu\n", sizeof(long long));

return 0;

}

*/

//%d : char short int

//%ld : long

//%lld: long long

//%u: unsigned char unsigned short unsigned int

//%lu: unsigned long

//%llu: unsigned long long

//%x: 打印十六进制

//%o: 打印八进制

//int main(int argc,const char *argv[])

//{

//    long long a=789;

//    printf("a = %lld", a);

//

//    unsigned int b=12;

//    printf("%u", b);

//

//    return 0;

//}

//浮点类型

//单精度   双精度    长双精度

//float   double   long double

//4字节    8字节     16字节

//int main(int argc, const char *argv[])

//{

//    printf("float = %lu\n", sizeof(float));

//    printf("double = %lu\n", sizeof(double));

//    printf("long double = %lu\n", sizeof(long double));

//

//    return 0;

//}

//浮点类型数据表示

//3.14

//科学计数法: 5678.678 5.678678 * 10^3;(不能在计算机中表示)

//指数法: 34.56  ==> 3.456e1

//int main(int argc,const char *argv[])

//{

//    float f1 = 3.14;//常用方式

//    printf("%f\n", f1);

//    float f2 = 3.456e1;//指数法

//    printf("%f\n", f2);

//    float f3 = 3.45e-2;

//    printf("%f\n", f3);

//

//    return 0;

//}

//浮点类型数据在内存中存储形式

//3.145   --> 0.3145e1

//-32.56  -->-0.3256e2

//1.符号位 2.小数位 3. 指数位

//float 精度 6~7位

//double 精度 15~16位

int main(int argc,const char *argv[])

{

float f1 = 567.2345434532345345;

printf("%f\n", f1);//%f

double f2 = 6798.34567876543234567876;

printf("%.20f\n", f2);//%lf %f

long double f3 = 34567.345678987654345678987654;

printf("%Lf\n", f3);//%Lf

return 0;

}

时间： 2024-10-13 16:27:31

IOS-C_Day2___进制编码的相关文章

c# 字符串（含有汉字）转化为16进制编码(转)

public static string Str2Hex(string s) { string result = string.Empty; byte[] arrByte = System.Text.Encoding.GetEncoding("GB2312").GetBytes(s); for(int i = 0; i < arrByte.Length; i++) { result += "&#x" + System.Convert.ToString(

二十四进制编码串转换为32位无符号整数（C语言实现）

typedef int BOOL; #define TRUE 1; #define FALSE 0; #define UINT_MAX 0xffffffff /* maximum unsigned int value */ enum Scale24AsciiVal { sav_aADis = 32, // 小写字母与大写字母ASCII码差值 sav_chIntDis = 48, // 字符'0'ASCII码值 }; static const char scale24[24] = {'0', '1

64进制编码转换

由于项目需要把一个ID(数字)压缩成尽可能短字符串,在网上找来好久没有找到合适, 自己动手写一个. 有需要的可以参考一下,也作为自己的一些积累吧! 代码如下: Java代码   /** * 64进制和10进制的转换类 * @author Administrator * */ public class compressEncodeing { final static char[] digits = { '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , 

iOS 16进制字符串转换成int十进制

NSRange rangeErr; rangeErr.location = 6; rangeErr.length = 2; NSString *strings = [value substringWithRange:rangeErr]; int errCode = (int)strtoul([strings UTF8String],0,16);  //16进制字符串转换成int NSString *ascStr = [NSString stringWithFormat:@"%c",re

python3 Unicode字符与16进制编码互转（单个字符）

def Unicode2HexChar(Unicde_Char):#Unicode转16进制 Hex_Char = "" for i in range(0, len(Unicde_Char)): Hex_Char += (hex(ord(Unicde_Char[i])).replace('0x','').zfill(4)) return Hex_Char print(Unicode2HexChar('.')) def HexChar2Unicode(Hex_Char):#16进制转Un

Verilog--二进制编码到格雷码的转换

二进制编码:bincode,格雷编码:graycode,则两者转化关系为: graycode = (bincode>>1) ^ bincode; 即二进制编码右移一位然后与原来二进制编码异或. 举例说明: 二进制 格雷0000 >> 1 = 0000 ^ 0000 = 0000 0001 >> 1 = 0000 ^ 0001 = 0001 0010 >> 1 = 0001 ^ 0010 = 0011 0011 >> 1 = 0001 ^ 0011

16进制编码解码

public string EncodingSMS(string s) { string result = string.Empty; byte[] arrByte = System.Text.Encoding.GetEncoding("GB2312").GetBytes(s); for(int i = 0; i < arrByte.Length; i++) { result += System.Convert.ToString(arrByte[i], 16); //Conver

16进制格式数据传输的服务框架——xxl-hex

github:https://github.com/xuxueli/xxl-hex git.osc:http://git.oschina.net/xuxueli0323/xxl-hex 博客地址(内附使用教程):http://www.cnblogs.com/xuxueli/p/5003305.html Tips:这篇基于hex的通讯方案,和网上其他的,或者你目前了解的完全不是同一个玩意儿,疑惑看代码: 简介:xxl-hex是一个轻量级的remoting onhttp工具,使用简单的方法提供了rp

如何将 16进制字符串形式的图片显示到页面上

前言:如果数据库中存放的图片信息不是图片的链接,而是存放图片的16进制字符串(这种存放方式很low,很影响数据库查询效率,还是存放图片链接好).这时如果想要将图片显示在jsp页面上,java代码应该怎么处理了? 例如:(图片和它的16进制编码) 处理步骤: 1.后台代码剪辑 import cn.com.syan.spark.app.sdk.connect.utils.http.BASE64Encoder; //处理代码 BASE64Encoder encoder = new BASE64Enco