精华内容
下载资源
问答
  • 【常见数据类型占多少字节问题】

    千次阅读 2017-08-22 22:02:19
    因为指针记录的就是一个地址,那么32的就是4字节,64的就是8字节。int占多少个字节既由编译器决定,也由CPU或虚拟机或操作系统决定,但归根结底是由编译器决定。 OS:Linux jiabei-PC 4.9.0-deepin10-am

    指针长度和地址总线有关。因为指针记录的就是一个地址,那么32位的就是4字节,64位的就是8字节。int占多少个字节既由编译器决定,也由CPU或虚拟机或操作系统决定,但归根结底是由编译器决定。


    OS:Linux jiabei-PC 4.9.0-deepin10-amd64 #1 SMP PREEMPT Deepin 4.9.40-1 (2017-07-28) x86_64 GNU/Linux。

    IDE:Code::Blocks 16.01--64bit 


    【测试代码】


    #include <bits/stdc++.h>
    using namespace std;
    int main(){
        double *o = NULL;
        cout<<sizeof(char)<<endl;
        cout<<sizeof(short)<<endl;
        cout<<sizeof(int)<<endl;
        cout<<sizeof(float)<<endl;
        cout<<sizeof(long)<<endl;
        cout<<sizeof(double)<<endl;
        cout<< sizeof(char *) << sizeof(short *) << sizeof(int *) << sizeof(o) << sizeof(double *)<<endl;
        return 0;
        }

    结果为:

    1
    2
    4
    4
    8
    8
    88888


    由上可知,64OS与64bit编译器下char占1字节,short占 2 字节,int 、float、都占 4 字节,long,double 占8 字节,任意类型的指针都占8个字节。

    另32bit编译器测试结果:char占1字节,short占 2 字节,int 、float、long都占 4 字节,double 占8 字节,任意类型的指针都占4个字节。


    展开全文
  • win7系统开始,就分为64位和32位,什么位的操作系统一般是由用户的硬件配置... 其实我们说的32位和64位,指的是CPU每次处理多少位的数据。对于32位CPU,其次只能处理32位(即4个字节)的数据;而64位CPU次...

      win7系统开始,就分为64位和32位,什么位的操作系统一般是由用户的硬件配置决定;32位系统最大只能支持3.5GB内存,如果在32位系统中使用的是4GB或者更大容量内存,电脑只可以识别到3.4GB可用,而64位系统最大可以支持128GB大内存。

      其实我们说的32位和64位,指的是CPU每一次处理多少位的数据。对于32位CPU,其一次只能处理32位(即4个字节)的数据;而64位CPU一次可以处理64位(即8个字节)的数据。

    Windows系统查看位数

    此电脑---右键----属性

    已安装的内存 显示的是内存大小

    系统类型可显示操作系统的位数

    Windows查看CPU核数

    此电脑---右键---属性-----设备管理器---处理器显示4个,则为4核

    综上,则以上的操作系统为64位Windows10操作系统 4核CPU 8G内存

    Linux系统查看位数

    在linux终端输入 getconf LONG_BIT 命令
    如果是32位机器,则结果为32 64位则显示64

    Linux查看核数

    在linux终端输入 cat /proc/cpuinfo | grep "cpu cores" | uniq   显示个数即为核数

    Linux查看内存大小

    cat /proc/meminfo | grep MemTotal

    综上,Linux系统为64位系统,1核,2G内存

    展开全文
  • 入门学习Linux常用必会60命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    Linux一个真正的多用户操作系统,可以同时接受多个用户登录,还允许一个用户进行多次登录。这是因为Linux和许多版本的Unix一样,提供了虚拟控制台的访问方式,允许用户在同一时间从控制台(系统的控制台是与系统...
  • Linux网络编程

    2019-09-07 18:06:26
    一个文件描述符指向一个套接字(套接字内部由内核借助两个缓冲区实现) 网络字节序: 小端法(PC):高位存高地址,地位存地址 大端法(网络):高位存低地址,地位存高地址 TCP/IP协议规定,网络数据流采用...

    Socket

    一个文件描述符指向一个套接字(套接字内部由内核借助两个缓冲区实现)

     

    网络字节序:

    小端法(PC):高位存高地址,地位存地址

    大端法(网络):高位存低地址,地位存高地址

    TCP/IP协议规定,网络数据流采用大端字节序;而主机当中使用的是小端法,需要做网络字节序和主机字节序的转换。

    4字节整数a的存储示意如图所示:

    写个小程序,把a的最低位输出来,看看是多少。

    #include<stdio.h>
    int main(int argc, char const *argv[])
    {
    	printf("%d\n",sizeof(int) );
    	unsigned int a=0x12345678;
    	printf("%c\n", a);
    	printf("%c\n", *((char*)&a+1));
    	printf("%c\n",*((char*)&a+2));
    	printf("%c\n", *((char*)&a+3));
    	return 0;
    }

    上面程序输出为x,小写x的ASCII值为120,而0x78转换为10进制就是120。

    大写V,ASCII值为86,对应16进制为56。可以看出电脑上是小端法存储。

    有4个函数专门用于转换:

    #include <arpa/inet.h>
    
    uint32_t htonl(uint32_t hostlong);
    
    uint16_t htons(uint16_t hostshort);
    
    uint32_t ntohl(uint32_t netlong);
    
    uint16_t ntohs(uint16_t netshort);
    

    h表示host,n表示network,l表示32位,s表示16位。

    htonl:本地->网络(IP)

    htons:本地->网络(port)

    ntohl:网络->本地(IP)

    ntohs:网络->本地(port)

    IP地址转换函数

    inet_pton:点分十进制字符串转换为网络字节序

    inet_ntop:网络字节序转换为点分十进制字符串

    这两个函数都支持IPv4和IPv6.

    #include <arpa/inet.h>
    
    int inet_pton(int af, const char *src, void *dst);
    

    af:表示地址类型,只有两个选择,AF_INET表示IPv4,AF_INET6表示IPv6

    src:要转换的IP(点分十进制字符串)

    det:转换后的网络字节序的IP地址

    返回值:

              成功:1

              异常:0,表示scr指向的不是一个有效的IP地址

              失败:-1

    #include <arpa/inet.h>
    
    const char *inet_ntop(int af, const void *src,char *dst, socklen_t size)

    af:AF_INET、AF_INET6

    scr:网络字节序的IP地址

    dst:本地字节序(string IP)

    size:dst的大小

    返回值:

            成功:dst

           失败:NULL;

    https://blog.csdn.net/bian_qing_quan11/article/details/71699371

    inet_ntoa:网络字节序转换为点分十进制IP

    char *inet_ntoa(struct in_addr in);

    inet_aton:点分十进制IP转换为网络字节序存放在addr中,成功返回1,失败返回0。

    inet_aton() returns 1 if the supplied string was successfully interpreted, or 0 if the string is  invalid  (errno  is  not  set  on
     error).

    int inet_aton(const char *cp, struct in_addr *inp);

    inet_network:将点分十进制IP转化为主机字节序(二进制位小端存储) 

    in_addr_t inet_network(const char *cp);

    inet_addr:将点分十进制IP转化为网络字节序(二进制位的大端存储)。

    in_addr_t inet_addr(const char *cp);
    #include <stdio.h>
    #include <arpa/inet.h>
    
    
    int main(int argc, char const *argv[])
    {
    	struct in_addr in;
    	
    	printf("点分十进制ip地址:192.168.1.1\n");
    	printf("主机字节序:%u\n",inet_network("192.168.1.1"));
    	inet_aton("192.168.1.1",&in);
    	printf("网络字节序:%u\n",in.s_addr);
    	in.s_addr = htonl(inet_network("192.168.1.1"));
    	printf("点分十进制ip地址:%s\n",inet_ntoa(in));
    	return 0;
    }

     192.168.1.1转换成二进制为11000000 10101000 00000001 00000001,转换为十进制为3,232,235,777‬,大端存储为00000001 00000001 10101000 11000000,即16,885,952‬。

    sockaddr数据结构

    早期的socket数据结构,sockaddr数据结构其实已经不用了,但因为Linux当中很多函数以前用的这个数据结构,不好对这些函数进行更改,就保留了sockaddr数据结构,它就扮演着void *差不多的角色,用作地址转换中介。例如bind的函数当中参数类型还是sockaddr*类型,使用时需要进行地址类型转换。

    int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    

    sturct sockaddr_in addr;                    man 7 ip查看sockaddr_in结构体信息。

    addr.sin_family=AF_INT;      (sin,socket internet??)

    addr.sin_port=htons(9527);

    //int dst;

    //inet_pton(AR_INET,"11.11.11.11",(void*)&dst);

    //add.sin_addr.s_addr=dst;

    addr.sin_addr.s_addr=htonl(INADDR_ANY);取出系统中有效的任意IP地址,二进制类型。INADDR_ANY是一个宏。

    bind(fd,(struct sockaddr*)&addr,size);

    struct sockaddr_in:这个in表示internet,不是进入哈哈(我前两天一直以为是输入,很懵逼)

    man 7 ip查看sockaddr_in数据结构

    struct sockaddr_in {
                   sa_family_t    sin_family; /* address family: AF_INET */
                   in_port_t      sin_port;   /* port in network byte order */
                   struct in_addr sin_addr;   /* internet address */
               };
    
    /* Internet address. */
    struct in_addr {
         uint32_t       s_addr;     /* address in network byte order */
    };
    

    sockaddr_un是本地进程通信的数据结构。

    socket模型创建流程

    socket():创建一个套接字,返回一个文件描述符fd,也叫句柄。

    bind():绑定IP+端口

    listen():设置监听上线,表示同时能连接的客户端数量

    accept():阻塞监听客户端连接

     

    connet(),绑定IP和端口

    socket函数

    socket()

    #include <sys/socket.h>
    int socket(int domain, int type, int protocol);
    

    domain:通信协议,AF_INET、AF_INET6、AF_UNIX、AF_NETLINK等

    type:数据传输方式,有SOCK_STREAM、SOCK_DGRAM、SOCK_RAW等

    protocol:对应协议,当protocol为0时,会自动选择type类型对应的默认协议

    正如大家所想,一般情况下有了 af 和 type 两个参数就可以创建套接字了,操作系统会自动推演出协议类型,除非遇到这样的情况:有两种不同的协议支持同一种地址类型和数据传输类型。如果我们不指明使用哪种协议,操作系统是没办法自动推演的。
    使用 IPv4 地址,参数 af 的值为 PF_INET。如果使用 SOCK_STREAM 传输数据,那么满足这两个条件的协议只有 TCP,因此可以这样来调用 socket() 函数:

    int tcp_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  //IPPROTO_TCP表示TCP协议

    返回值:成功返回文件描述符,错误返回-1。

    /usr/include/x86_64-linux-gnu/bits/socket.h
    /* Protocol families.  */
    #define PF_UNSPEC	0	/* Unspecified.  */
    #define PF_LOCAL	1	/* Local to host (pipes and file-domain).  */
    #define PF_UNIX		PF_LOCAL /* POSIX name for PF_LOCAL.  */
    #define PF_FILE		PF_LOCAL /* Another non-standard name for PF_LOCAL.  */
    #define PF_INET		2	/* IP protocol family.  */
    #define PF_AX25		3	/* Amateur Radio AX.25.  */
    #define PF_IPX		4	/* Novell Internet Protocol.  */
    #define PF_APPLETALK	5	/* Appletalk DDP.  */
    #define PF_NETROM	6	/* Amateur radio NetROM.  */
    #define PF_BRIDGE	7	/* Multiprotocol bridge.  */
    #define PF_ATMPVC	8	/* ATM PVCs.  */
    #define PF_X25		9	/* Reserved for X.25 project.  */
    #define PF_INET6	10	/* IP version 6.  */
    #define PF_ROSE		11	/* Amateur Radio X.25 PLP.  */
    #define PF_DECnet	12	/* Reserved for DECnet project.  */
    #define PF_NETBEUI	13	/* Reserved for 802.2LLC project.  */
    #define PF_SECURITY	14	/* Security callback pseudo AF.  */
    #define PF_KEY		15	/* PF_KEY key management API.  */
    #define PF_NETLINK	16
    #define PF_ROUTE	PF_NETLINK /* Alias to emulate 4.4BSD.  */
    #define PF_PACKET	17	/* Packet family.  */
    #define PF_ASH		18	/* Ash.  */
    #define PF_ECONET	19	/* Acorn Econet.  */
    #define PF_ATMSVC	20	/* ATM SVCs.  */
    #define PF_RDS		21	/* RDS sockets.  */
    #define PF_SNA		22	/* Linux SNA Project */
    #define PF_IRDA		23	/* IRDA sockets.  */
    #define PF_PPPOX	24	/* PPPoX sockets.  */
    #define PF_WANPIPE	25	/* Wanpipe API sockets.  */
    #define PF_LLC		26	/* Linux LLC.  */
    #define PF_IB		27	/* Native InfiniBand address.  */
    #define PF_MPLS		28	/* MPLS.  */
    #define PF_CAN		29	/* Controller Area Network.  */
    #define PF_TIPC		30	/* TIPC sockets.  */
    #define PF_BLUETOOTH	31	/* Bluetooth sockets.  */
    #define PF_IUCV		32	/* IUCV sockets.  */
    #define PF_RXRPC	33	/* RxRPC sockets.  */
    #define PF_ISDN		34	/* mISDN sockets.  */
    #define PF_PHONET	35	/* Phonet sockets.  */
    #define PF_IEEE802154	36	/* IEEE 802.15.4 sockets.  */
    #define PF_CAIF		37	/* CAIF sockets.  */
    #define PF_ALG		38	/* Algorithm sockets.  */
    #define PF_NFC		39	/* NFC sockets.  */
    #define PF_VSOCK	40	/* vSockets.  */
    #define PF_KCM		41	/* Kernel Connection Multiplexor.  */
    #define PF_QIPCRTR	42	/* Qualcomm IPC Router.  */
    #define PF_SMC		43	/* SMC sockets.  */
    #define PF_MAX		44	/* For now..  */
    /* Address families.  */
    #define AF_UNSPEC	PF_UNSPEC
    #define AF_LOCAL	PF_LOCAL
    #define AF_UNIX		PF_UNIX
    #define AF_FILE		PF_FILE
    #define AF_INET		PF_INET
    #define AF_AX25		PF_AX25
    #define AF_IPX		PF_IPX
    #define AF_APPLETALK	PF_APPLETALK
    #define AF_NETROM	PF_NETROM
    #define AF_BRIDGE	PF_BRIDGE
    #define AF_ATMPVC	PF_ATMPVC
    #define AF_X25		PF_X25
    #define AF_INET6	PF_INET6
    #define AF_ROSE		PF_ROSE
    #define AF_DECnet	PF_DECnet
    #define AF_NETBEUI	PF_NETBEUI
    #define AF_SECURITY	PF_SECURITY
    #define AF_KEY		PF_KEY
    #define AF_NETLINK	PF_NETLINK
    #define AF_ROUTE	PF_ROUTE
    #define AF_PACKET	PF_PACKET
    #define AF_ASH		PF_ASH
    #define AF_ECONET	PF_ECONET
    #define AF_ATMSVC	PF_ATMSVC
    #define AF_RDS		PF_RDS
    #define AF_SNA		PF_SNA
    #define AF_IRDA		PF_IRDA
    #define AF_PPPOX	PF_PPPOX
    #define AF_WANPIPE	PF_WANPIPE
    #define AF_LLC		PF_LLC
    #define AF_IB		PF_IB
    #define AF_MPLS		PF_MPLS
    #define AF_CAN		PF_CAN
    #define AF_TIPC		PF_TIPC
    #define AF_BLUETOOTH	PF_BLUETOOTH
    #define AF_IUCV		PF_IUCV
    #define AF_RXRPC	PF_RXRPC
    #define AF_ISDN		PF_ISDN
    #define AF_PHONET	PF_PHONET
    #define AF_IEEE802154	PF_IEEE802154
    #define AF_CAIF		PF_CAIF
    #define AF_ALG		PF_ALG
    #define AF_NFC		PF_NFC
    #define AF_VSOCK	PF_VSOCK
    #define AF_KCM		PF_KCM
    #define AF_QIPCRTR	PF_QIPCRTR
    #define AF_SMC		PF_SMC
    #define AF_MAX		PF_MAX

     

    /usr/include/x86_64-linux-gnu/bits/socket_type.h
    /* Types of sockets.  */
    enum __socket_type
    {
      SOCK_STREAM = 1,		/* Sequenced, reliable, connection-based
    				   byte streams.  */
    #define SOCK_STREAM SOCK_STREAM
      SOCK_DGRAM = 2,		/* Connectionless, unreliable datagrams
    				   of fixed maximum length.  */
    #define SOCK_DGRAM SOCK_DGRAM
      SOCK_RAW = 3,			/* Raw protocol interface.  */
    #define SOCK_RAW SOCK_RAW
      SOCK_RDM = 4,			/* Reliably-delivered messages.  */
    #define SOCK_RDM SOCK_RDM
      SOCK_SEQPACKET = 5,		/* Sequenced, reliable, connection-based,
    				   datagrams of fixed maximum length.  */
    #define SOCK_SEQPACKET SOCK_SEQPACKET
      SOCK_DCCP = 6,		/* Datagram Congestion Control Protocol.  */
    #define SOCK_DCCP SOCK_DCCP
      SOCK_PACKET = 10,		/* Linux specific way of getting packets
    				   at the dev level.  For writing rarp and
    				   other similar things on the user level. */
    #define SOCK_PACKET SOCK_PACKET
    
      /* Flags to be ORed into the type parameter of socket and socketpair and
         used for the flags parameter of paccept.  */
    
      SOCK_CLOEXEC = 02000000,	/* Atomically set close-on-exec flag for the
    				   new descriptor(s).  */
    #define SOCK_CLOEXEC SOCK_CLOEXEC
      SOCK_NONBLOCK = 00004000	/* Atomically mark descriptor(s) as
    				   non-blocking.  */
    #define SOCK_NONBLOCK SOCK_NONBLOCK
    };
    /usr/include/linux/in.h
    #if __UAPI_DEF_IN_IPPROTO
    /* Standard well-defined IP protocols.  */
    enum {
      IPPROTO_IP = 0,		/* Dummy protocol for TCP		*/
    #define IPPROTO_IP		IPPROTO_IP
      IPPROTO_ICMP = 1,		/* Internet Control Message Protocol	*/
    #define IPPROTO_ICMP		IPPROTO_ICMP
      IPPROTO_IGMP = 2,		/* Internet Group Management Protocol	*/
    #define IPPROTO_IGMP		IPPROTO_IGMP
      IPPROTO_IPIP = 4,		/* IPIP tunnels (older KA9Q tunnels use 94) */
    #define IPPROTO_IPIP		IPPROTO_IPIP
      IPPROTO_TCP = 6,		/* Transmission Control Protocol	*/
    #define IPPROTO_TCP		IPPROTO_TCP
      IPPROTO_EGP = 8,		/* Exterior Gateway Protocol		*/
    #define IPPROTO_EGP		IPPROTO_EGP
      IPPROTO_PUP = 12,		/* PUP protocol				*/
    #define IPPROTO_PUP		IPPROTO_PUP
      IPPROTO_UDP = 17,		/* User Datagram Protocol		*/
    #define IPPROTO_UDP		IPPROTO_UDP
      IPPROTO_IDP = 22,		/* XNS IDP protocol			*/
    #define IPPROTO_IDP		IPPROTO_IDP
      IPPROTO_TP = 29,		/* SO Transport Protocol Class 4	*/
    #define IPPROTO_TP		IPPROTO_TP
      IPPROTO_DCCP = 33,		/* Datagram Congestion Control Protocol */
    #define IPPROTO_DCCP		IPPROTO_DCCP
      IPPROTO_IPV6 = 41,		/* IPv6-in-IPv4 tunnelling		*/
    #define IPPROTO_IPV6		IPPROTO_IPV6
      IPPROTO_RSVP = 46,		/* RSVP Protocol			*/
    #define IPPROTO_RSVP		IPPROTO_RSVP
      IPPROTO_GRE = 47,		/* Cisco GRE tunnels (rfc 1701,1702)	*/
    #define IPPROTO_GRE		IPPROTO_GRE
      IPPROTO_ESP = 50,		/* Encapsulation Security Payload protocol */
    #define IPPROTO_ESP		IPPROTO_ESP
      IPPROTO_AH = 51,		/* Authentication Header protocol	*/
    #define IPPROTO_AH		IPPROTO_AH
      IPPROTO_MTP = 92,		/* Multicast Transport Protocol		*/
    #define IPPROTO_MTP		IPPROTO_MTP
      IPPROTO_BEETPH = 94,		/* IP option pseudo header for BEET	*/
    #define IPPROTO_BEETPH		IPPROTO_BEETPH
      IPPROTO_ENCAP = 98,		/* Encapsulation Header			*/
    #define IPPROTO_ENCAP		IPPROTO_ENCAP
      IPPROTO_PIM = 103,		/* Protocol Independent Multicast	*/
    #define IPPROTO_PIM		IPPROTO_PIM
      IPPROTO_COMP = 108,		/* Compression Header Protocol		*/
    #define IPPROTO_COMP		IPPROTO_COMP
      IPPROTO_SCTP = 132,		/* Stream Control Transport Protocol	*/
    #define IPPROTO_SCTP		IPPROTO_SCTP
      IPPROTO_UDPLITE = 136,	/* UDP-Lite (RFC 3828)			*/
    #define IPPROTO_UDPLITE		IPPROTO_UDPLITE
      IPPROTO_MPLS = 137,		/* MPLS in IP (RFC 4023)		*/
    #define IPPROTO_MPLS		IPPROTO_MPLS
      IPPROTO_RAW = 255,		/* Raw IP packets			*/
    #define IPPROTO_RAW		IPPROTO_RAW
      IPPROTO_MAX
    };
    #endif

     bind()

    int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    

    给socket绑定一个地址结构(IP+端口号),socket和sockaddr_in中的地址结构AF_INT等得一样。

    sockfd:socket函数返回值,文件描述符

                 sturct sockaddr_in addr;

                 addr.sin_family=AF_INT;     

                 addr.sin_port=htons(9527);

                 addr.sin_addr.s_addr=htonl(INADDR_ANY);

    addr:(struct sockaddr&)&addr,是传入参数

    addlen:sizeof(addr),地址结构的大小

    返回值:

              成功:0;失败:-1

    listen()

    int listen(int sockfd, int backlog);
    

    设置能够同时与服务器建立连接的客户端上线(同时进行3次握手的客户端数量)

    sockfd:socket函数返回值,文件描述符

    backlog:上限数值,最大为128。

    返回值:

              成功:0;失败:-1

    accept()

    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

    阻塞等待客户端建立连接,成功时返回一个与客户端成功连接的socket文件描述符

    sockfd:最开始建立的socket文件描述符

    addr:传出参数,成功与服务器建立连接的那个客户端的地址结构(IP+port)

    addrlen:传入传出参数。入:addr的大小,出:客户端addr的实际大小。

             socklen_t clit_addr_len = sizeof(struct sockaddr),传入参数&clit_addr_len。

    返回值:

            成功,返回新建立的socket的文件描述符,非负整数

            失败:-1

    connect()

    int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
    

    与服务器建立连接

    sockfd:socket函数返回值

    addr:传入参数,服务器地址结构

    addrlen:服务器地址结构长度

    返回值:成功0,失败-1。

    如果不使用bind绑定客户端地址结构,系统会“隐式绑定”。

    一个简单的例子,

    客户端给服务器发一串字符串,服务器将接受到字符串转换为大写,再发功给客户端。

    这里用的read、write函数,和recv、send区别后面再研究。

    //server.c
    #include<stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <ctype.h>
    #include <errno.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    
    #define SERVER_PORT 12345
    
    void sys_error(const char *str)
    {
    	perror(str);
    	exit(-1);
    }
    
     int main(int argc, char const *argv[])
    {
    	int sfd,cfd,ret=0;
    	socklen_t client_addr_len;
    	char buf[1024];
    	char client_IP[16];
    	struct sockaddr_in server_addr,client_addr;
    	server_addr.sin_family = AF_INET;
    	server_addr.sin_port = htons(SERVER_PORT);
    	server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    	sfd = socket(AF_INET,SOCK_STREAM,0);
    	if(sfd==-1)
    	{
    		sys_error("socket error");
    	}
    	ret = bind(sfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
    	if(ret==-1)
    	{
    		sys_error("bind error");
    	}
    
    	ret = listen(sfd,128);
    	if(ret==-1)
    	{
    		sys_error("listen error");
    	}
    	client_addr_len = sizeof(client_addr);
    	cfd = accept(sfd,(struct sockaddr*)&client_addr,&client_addr_len);
    	if(cfd==-1)
    	{
    		sys_error("accept error");
    	}
    	//打印连接上的客户端IP和端口号
    	printf("client_ip:%s port:%d\n",inet_ntop(AF_INET,&client_addr.sin_addr.s_addr,client_IP,sizeof(client_IP)),ntohs(client_addr.sin_port) );
    	while(1)
    	{
    		ret = read(cfd,buf,sizeof(buf));
    		write(STDOUT_FILENO,buf,ret);
    		for(int i=0;i<ret;i++)
    		{
    			buf[i] = toupper(buf[i]);
    		}
    		write(cfd,buf,ret);
    	}
    	
    	close(sfd);
    	close(cfd);
    	return 0;
    }

    还没有写客户端,可以nc命令模拟客户端

    #include<stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <ctype.h>
    #include <errno.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    
    #define SERVER_PORT 12347
    
    void sys_error(const char *str)
    {
    	perror(str);
    	exit(-1);
    }
    
     int main(int argc, char const *argv[])
    {
    	int cfd,ret=0;
    	char buf[1024];
    	struct sockaddr_in client_addr,server_addr;
    	server_addr.sin_family = AF_INET;
    	server_addr.sin_port = htons(SERVER_PORT);
    	//server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    	inet_pton(AF_INET,"127.0.0.1",&server_addr.sin_addr.s_addr);
    	cfd = socket(AF_INET,SOCK_STREAM,0);
    	if(cfd==-1)
    	{
    		sys_error("socket error");
    	}
    
    	ret = connect(cfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
    	if(ret==-1)
    	{
    		sys_error("connect error");
    	}
    
    	while(1)
    	{
    		//scanf("%s",buf);
    		gets(buf);//最好使用fgets。
    		write(cfd,buf,strlen(buf));
    		ret = read(cfd,buf,sizeof(buf));
    		write(STDOUT_FILENO,buf,ret);
    		printf("\n");
    	}
    	
    	close(cfd);
    	return 0;
    }

    TCP三次握手,对应的函数就是accept,connect。

    展开全文
  • LKD这本书虽然看过很多遍,但在工作中却发现一些小知识...出于某些历史和主观原因,一些操作系统根据数据长度把数据划分为字节(8)、字(16)、双字(32)、四字(64)。 2、char的符号问题 C标准里char类型可

    LKD这本书虽然看过很多遍,但在工作中却发现一些小知识点却容易被忽略,包括自己在内,因此有必须把一些小知识点再强化小结一下。


    1、字长
    能够由机器一次处理完成的数据被称为字。某处理器多少“位”,通常指的就是它的字长。
    出于某些历史和主观原因,一些操作系统根据数据长度把数据划分为字节(8位)、字(16位)、双字(32位)、四字(64位)。

    2、char的符号问题
    C标准里char类型可以带符号或不带符号,由编译器或处理器决定。大部分体系上,char默认是带符号的,但在ARM处理器上,char是不带符号的。比如当char默认不带符号时,
    char i = -1;
    它实际上把255赋给了i(整数在内存里是以补码的形式存放的,正数的补码是它本身,负数的补码是取绝对值,取反再加1)

    3、字节顺序
    大端big-endian:高字节存在内存低地址,低字节存在内存高地址。
    小端little-endian:高字节存在内存高低址,低字节存在内存低地址。
    ARM和i386都是小端字节顺序。
    下面例字可以判断机器的字节顺序:
    int x = 1;
    if(* (char *) &x == 1)
       /*小端字节顺序*/
    else
       /*大端字节顺序*/

    (*和&运算符的优先级相同,但按自在右向左的方向结合)

    4、内核里的时间
    不要假定内核中断发生的频率,应该使用HZ来计量时间,计量时间的正确方法是乘或除以HZ,比如
    HZ,2*HZ,HZ/2,HZ/1O

    展开全文
  • linux16.

    2019-10-08 18:49:07
    网络层 在复杂的网络环境中确定一个合适的路径. 基本概念 主机: 配有IP地址, 但是不进行路由控制的设备;... 4头部长度(header length): IP头部的长度是多少个32bit, 也就是 length * 4 的字节数. 4...
  • 在这一讲中,我们主要是了解一下 Linux 的概况,以及对 Linux一个初步的感性认识。 一.什么是LinuxLinux一个以 Intel 系列 CPU(CYRIX,AMD 的 CPU也可以)为硬件平台,完全免费的 UNIX 兼容系统,完全...
  • 首先理解一个概念,linux基本上使用的都是32的整数和32的指针来指向内存的,32的指针可寻址的最大地址空间是4G字节。系统直接使用的是32指针来寻址,而不像8086那样使用地址偏移量来寻址,了解win32内存结构...
  • ,在Win10系统下,先32位测试: 1.源码: 、VS2017测试: ...从上面可以得知只有指针类型变成了8个字节,因为指针里面存储的是数据的地址,而非数据本身。...说明:CentOS下查看当前机器多少位系统命令: ge...
  • Linux--深入解析IP协议

    2018-07-21 16:05:08
    IP协议属于网络层协议,它是网络层最终要的协议,没有之!首先我们先从IP协议的报头格式看起 IP协议报头格式 ...16为总长度:表示IP数据报整体占多少个字节(包含首部和有效载荷) 16标识:第二行是用...
  •  答案很简单,在32机器上,一个int是4个字节,两个int就是8个字节,sizeof(Node)就是8。好的,上面那个答案确实是8,那么再看下面这个结构体:struct node{ char a; int b;};问:这个时候sizeof(No...
  • LINUX内核可移植性

    千次阅读 2012-02-07 15:23:39
    关于linux内核的可移植性我不用多说,现在的...所以我们常听到机器是多少位的时候,就是指该机的字长。处理器通用寄存器的大小和它的字长是相同的。C语言定义的long类型总对等于机器字长。对于支持的每种体系结构
  • linux内核的可移植性

    千次阅读 2012-11-05 22:09:06
    linux内核的可移植性  关于linux内核的可移植性我不用多说,现在的linux操作系统,你装系统时应该很明白...所以我们常听到机器是多少位的时候,就是指该机的字长。处理器通用寄存器的大小和它的字长是相同的。C语
  • 除以8就是B(字节)数,每秒跑多少位字节 2.首先通过广播查找所有主机,通过包头信息查找需要传送的服务器地址和来自哪个服务器地址, 而地址就是MAC,每个服务器都有一个独一无二的MAC地址 ...
  • 关于linux内核的可移植性我不用多说,现在的linux操作系统,你装系统时...所以我们常听到机器是多少位的时候,就是指该机的字长。处理器通用寄存器的大小和它的字长是相同的。C语言定义的long类型总对等于机器字长。
  • Tencent后台服务器开发有一道题是计算一个结构体的sizeof的大小: struct strData { int m_Int; char m_Char;...系统为32的Unix机器,请问sizeof...在32系统中,int类型为4个字节,char类型为1个字节,short为2...
  • 一个题,找一个无序数组的中数 写了个快排,然后让我找到无序数组第k大的一个数,我说先排序再找,实际上可以用快排的partition函数。 快排的时间复杂度,最坏情况呢,最好情况呢,堆排序的时间复杂度呢,建堆...
  • 例如,对象头在64位Linux操作系统上,会占用16字节,然后如果你的实例对象内部有个int类型的实例变量,然后如果你的实例对象内部有个int类型的实例变量,则会占用四个字节,如果是龙类型实例变量,则会占用8个字节。...
  • 串口收发最高为0

    2013-05-19 15:24:19
    昨天在现场,读取电表度数的时候发现一个问题,读取字节最高不管多少全部为0. 搞的我相当郁闷。 最后没有办法,只好人工给他置1. 今天到了公司打开 《linux 程序设计》翻到终端这一章,152页, 赫然写着几...
  • cpu的是指一次性可处理的数据量是多少,1字节=8,32处理器可以一次性处理4个字节的数据量。如果用32标识内存中的一个地址,那么就只能有2的32次方=4G个地址了,所以32的cpu只能使用4G的内存了。 2.内核...
  • magic number介绍

    2017-02-13 19:32:08
    magic number:魔数,这是放在linux的目录中的文件信息块中的一个标识符,一般只有几,用来标识该文件是什么类型的文件,可以被什么样的应用使用。这个魔数不是固定的,有时候一个文件信息中的魔数可能会不断变化。...
  • #include <stdio.h> #include <stdlib.h> void arrayprint(int datas[],int ele) /重点2:1....2.括号中无论写多少,都不能代表形...在Linux64中用8个字节表示)/ { int i; printf(“数组的大小:%d\n”,
  • 32处理器中,每条指令都是4字节长度,以4个字节顺序存储 仅考虑顺序执行的情况下,处理器将按照指令顺序依次读出执行 但是如果考虑跳转执行的话,仅仅只有指令顺序存储这条件的情况下, 实现跳转执行唯一的方法...
  • 现在给定一个字典,用户输入一个单词,如何根据字典找出这个单词有多少个兄弟单词? 3.4.8 找出数组中出现次数超过一半的数,现在有一个数组,已知一个数出现的次数超过了一半,请用O(n)的复杂度的算法找出这个数。...
  • _u32是干嘛的

    千次阅读 2017-12-25 18:22:15
    原因:不能确定你的代码以后是否只在一个平台上运行,有可能会移植到非Linux平台,不同的CPU平台,比如64环境、非x86环境。而C语言中并未明确规定int占多少字节,所以_u32就是告诉别人,这变量占4
  • 操作系统(内存管理)

    热门讨论 2009-09-20 12:55:25
    void *malloc(long numbytes):该函数负责分配 numbytes 大小的内存,并返回指向第一个字节的指针。 void free(void *firstbyte):如果给定一个由先前的 malloc 返回的指针,那么该函数会将分配的空间归还给进程的...
  • void *malloc(long numbytes):该函数负责分配 numbytes 大小的内存,并返回指向第一个字节的指针。 void free(void *firstbyte):如果给定一个由先前的 malloc 返回的指针,那么该函数会将分配的空间归还给进程...
  • 上篇基本上是第一版的修订,只是做了一个调整,那便是在兼顾 Windows和Linux两方面用户的基础上,默认在Linux下建立开发环境来编写我们的操作系统。至于这样做的原因,在本书第 2章有比较详细的说明。当然,开发环境...

空空如也

空空如也

1 2 3
收藏数 45
精华内容 18
关键字:

linux一个字节多少位

linux 订阅