C++网络编程读书笔记2—类的封装

最新推荐文章于 2023-06-12 01:30:32 发布
最新推荐文章于 2023-06-12 01:30:32 发布
阅读量465 收藏
点赞数
分类专栏： C++网络编程 文章标签： 读书 c++ 编程 网络 socket struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/youfangyuan/article/details/6761977
版权

 服务器客户端通信—类的封装

#ifndef _YFY_ADDR_H
#define _YFY_ADDR_H

#include <sys/types.h>
#include <sys/socket.h>
#include   <netinet/in.h> 
#include   <netdb.h> 
#include   <sys/stat.h> 
#include   <fcntl.h> 
#include   <dirent.h> 
#include   <sys/time.h> 
#include   <unistd.h> 
#include   <errno.h> 
#include   <net/if.h> 
#include   <arpa/inet.h>
#include <string.h>

#define DEFAULT_PORT 8890

class YFY_Addr
{
public:
    YFY_Addr(int type = AF_INET, char *ip = 0, unsigned int port = DEFAULT_PORT);
    void setFamily(sa_family_t );
    void setPort(unsigned int port);
    void setIp(const char *str_ip);
    void setIp(unsigned int ip);
    bool operator == (const YFY_Addr &sap) const;
    bool operator !=(const YFY_Addr &sap)const;
    unsigned int getPort();
    void getIp(const char * str_ip);
    unsigned int getSize() const;
    const void *getAddr() const;
    struct sockaddr * convert() const;
	
private:
    struct sockaddr_in _addr;
};
#endif

#include "../inc/YFY_Addr.h"
	
YFY_Addr::YFY_Addr(int type/* = AF_INET*/, char *ip/* = 0*/, unsigned int port/* = DEFAULT_PORT*/)
{
    bzero(&_addr, sizeof(_addr));
    _addr.sin_family = type;
    if(ip)
        _addr.sin_addr.s_addr = inet_addr(ip);
    else
        _addr.sin_addr.s_addr = htonl(INADDR_ANY);
    _addr.sin_port = htons(port);
}

void YFY_Addr::setFamily(sa_family_t family)
{
    _addr.sin_family = family;
}

void YFY_Addr::setPort(unsigned int port)
{
    _addr.sin_port = htons(port);
}

void YFY_Addr::setIp(const char * str_ip)
{
    if(0 == str_ip || 0 == strcmp("hostname", str_ip))
        _addr.sin_addr.s_addr = htonl(INADDR_ANY);
    else
        _addr.sin_addr.s_addr = inet_addr(str_ip);
}

void YFY_Addr::setIp(unsigned int ip)
{
    _addr.sin_addr.s_addr = htonl(ip);
}

bool YFY_Addr::operator==(const YFY_Addr &sap) const
{

    return 0 == memcmp(&_addr, sap.getAddr(), sap.getSize());
}

bool YFY_Addr::operator!=(const YFY_Addr &sap) const
{

    return 0 != memcmp(&_addr, sap.getAddr(), sap.getSize());
}

unsigned int YFY_Addr::getSize() const
{
    return sizeof(_addr);
}

const void * YFY_Addr::getAddr() const
{
    return &_addr;
}

struct sockaddr * YFY_Addr::convert() const
{
    return (struct sockaddr *)&_addr;
}



#ifndef _YFY_SOCKET_H
#define _YFY_SOCKET_H

#include <sys/types.h>
#include <sys/socket.h>
#include "YFY_Addr.h"

class YFY_Socket
{
public:
    int setOption(int level, int  opt_type, const void *optval, socklen_t optlen);
    int getOption(int level, int  opt_type, void *optval, socklen_t *optlen);
    int close();
    int getFileDescriptor();
    void setFileDescriptor(int sock);
    int getLocalAddr(YFY_Addr &) const;
    int getRemoteAddr(YFY_Addr &) const;
	
protected:
    YFY_Socket();
    ~YFY_Socket();
	
protected:
    int _sockfd;
};
#endif

#include "../inc/YFY_Socket.h"

YFY_Socket::YFY_Socket()
{
}

YFY_Socket::~YFY_Socket()
{
}

void YFY_Socket::setFileDescriptor(int sock)
{
    _sockfd = sock;

}

int YFY_Socket::getFileDescriptor()
{
    return _sockfd;

}

int YFY_Socket::setOption(int level, int opt_type, const void * optval, socklen_t optlen)
{
    setsockopt(_sockfd, level, opt_type, optval, optlen);
}

int YFY_Socket::getOption(int level, int opt_type, void * optval, socklen_t * optlen)
{

    getsockopt(_sockfd, level, opt_type, optval, optlen);
}

int YFY_Socket::close()
{
    return ::close(_sockfd);
}

int YFY_Socket::getLocalAddr(YFY_Addr & addr) const
{
    struct sockaddr_in local_addr;
    socklen_t addrlen;

    if(0 == getsockname(_sockfd, (struct sockaddr *)&local_addr, &addrlen))
    {        
        addr.setFamily(local_addr.sin_family);
        addr.setIp(local_addr.sin_addr.s_addr);
        addr.setPort(local_addr.sin_port);
    }
}

int YFY_Socket::getRemoteAddr(YFY_Addr & addr) const
{
    struct sockaddr_in peer_addr;
    socklen_t addrlen;

    if(0 == getpeername(_sockfd, (struct sockaddr *)&peer_addr, &addrlen))
    {
        addr.setFamily(peer_addr.sin_family);
        addr.setIp(peer_addr.sin_addr.s_addr);
        addr.setPort(peer_addr.sin_port);
    }
}



#ifndef _YFY_SOCK_ACCEPTOR_H
#define _YFY_SOCK_ACCEPTOR_H

#include "YFY_Addr.h"
#include "YFY_Tcp_Socket.h"

class YFY_Sock_Acceptor
{

public:
    YFY_Sock_Acceptor(YFY_Tcp_Socket * sock = 0);
    ~YFY_Sock_Acceptor();
    int open(YFY_Addr * addr);
    void setSocket(YFY_Tcp_Socket *sock = 0);
    YFY_Tcp_Socket *accept();
	
private:
    YFY_Tcp_Socket *_sock;
    YFY_Addr * _addr;
};
#endif

#include "../inc/YFY_Sock_Acceptor.h"

YFY_Sock_Acceptor::YFY_Sock_Acceptor(YFY_Tcp_Socket * sock/* = 0*/)
{
    _sock = sock;
}

YFY_Sock_Acceptor::~YFY_Sock_Acceptor()
{
}

int YFY_Sock_Acceptor::open(YFY_Addr *addr)
{
    _addr = addr;
    if(0 != bind(_sock->getFileDescriptor(), addr->convert(), addr->getSize()))
        return -1;
    if(0 != listen(_sock->getFileDescriptor(), 1))
        return -1;
    return 0;
}

void YFY_Sock_Acceptor::setSocket(YFY_Tcp_Socket * sock/* = 0*/)
{
    _sock = sock;
}

YFY_Tcp_Socket * YFY_Sock_Acceptor::accept()
{
    int peer_fd;
    unsigned int addr_len;
    YFY_Tcp_Socket *nsock = 0;

    peer_fd = ::accept(_sock->getFileDescriptor(), _addr->convert(), &addr_len);
    if(-1 == peer_fd)
        return 0;
    nsock = new YFY_Tcp_Socket(peer_fd);

    return nsock;
}

#ifndef _YFY_SOCK_CONNECTOR_H
#define _YFY_SOCK_CONNECTOR_H

#include "../inc/YFY_Addr.h"
#include "../inc/YFY_Time_Value.h"
#include "../inc/YFY_Tcp_Socket.h"

class YFY_Sock_Connector
{
public:
    YFY_Sock_Connector();
    ~YFY_Sock_Connector();
    /*non-block*/
    int connect(YFY_Addr & serv_addr, YFY_Tcp_Socket &serv_sock, YFY_Time_Value  *time = 0);
};
#endif

#include "../inc/YFY_Sock_Connector.h"

YFY_Sock_Connector::YFY_Sock_Connector()
{
}

YFY_Sock_Connector::~YFY_Sock_Connector()
{
}

int YFY_Sock_Connector::connect(YFY_Addr & serv_addr, YFY_Tcp_Socket & serv_sock, YFY_Time_Value * timeout/* = 0*/)
{
    int flags;
    int sockfd;
    int n;
    int error;
    int result;
    socklen_t len;
    fd_set rset, wset;
    struct timeval tvalue;

    sockfd = serv_sock.getFileDescriptor();
    if(!timeout)
        return ::connect(sockfd, serv_addr.convert(), serv_addr.getSize());
	
    else
    {
        flags = fcntl(sockfd, F_GETFL, 0);
        fcntl(sockfd,  F_SETFL, flags | O_NONBLOCK);

        result = ::connect(sockfd, serv_addr.convert(), serv_addr.getSize());
        if(result != EINPROGRESS)
            return -1;
        if(0 == result)
            return 0;

        FD_ZERO(&rset);
        FD_SET(sockfd, &rset);
        wset = rset;
        tvalue.tv_sec = timeout->getSec();
        tvalue.tv_usec = timeout->getUsec();

        n = select(sockfd + 1, &rset, &wset, NULL, &tvalue);
        if(!n)
        {
            serv_sock.close();
            return -1;
        }
        if(FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset))
        {
            len = sizeof(error);
            if(serv_sock.getOption(SOL_SOCKET, SO_ERROR, &error, &len) < 0)
                return -1;
        }
        else
            return -1;

        fcntl(sockfd, F_SETFL, flags);
        if(error)
        {
            serv_sock.close();
            return -1;
        }
        return 0;
    }
}

#ifndef _YFY_TCP_SOCKET_H
#define _YFY_TCP_SOCKET_H

#include "../inc/YFY_Time_Value.h"
#include "../inc/YFY_Socket.h"

class YFY_Tcp_Socket : public YFY_Socket
{

public:
    YFY_Tcp_Socket();
    YFY_Tcp_Socket(int sockfd);
    ~YFY_Tcp_Socket();
    int recv(void *buff, unsigned int nbytes, int flags, YFY_Time_Value *timeout = 0);
    int send(const void *buff, unsigned int nbytes, int flags);
    int readv(const struct iovec *iov, int iovcnt , YFY_Time_Value *timeout = 0);
    int writev(const struct iovec *iov, int iovcnt);
    int recvMsg(struct msghdr * msg, int flags, YFY_Time_Value *timeout = 0);
    int sendMsg(struct msghdr * msg, int flags);
};
#endif

#include "../inc/YFY_Tcp_Socket.h"

YFY_Tcp_Socket::YFY_Tcp_Socket()
{
    _sockfd = socket(AF_INET, SOCK_STREAM, 0);
}

YFY_Tcp_Socket:: YFY_Tcp_Socket(int sockfd)
{
    setFileDescriptor(sockfd);
}

YFY_Tcp_Socket::~YFY_Tcp_Socket()
{
}

int YFY_Tcp_Socket::recv(void *buff, unsigned int nbytes, int flags, YFY_Time_Value *timeout/* = 0*/)
{
    int sockfd;
    int retval;
    socklen_t len;
    fd_set rset;
    struct timeval tvalue;

    sockfd = _sockfd;
    if(!timeout)
        return  ::recv(sockfd, buff, nbytes, flags);
	
    else
    {
        FD_ZERO(&rset);
        FD_SET(sockfd, &rset);
		
        tvalue.tv_sec = timeout->getSec();
        tvalue.tv_usec = timeout->getUsec();

        retval= select(sockfd + 1, &rset, NULL, NULL, &tvalue);
        if (retval == -1)
            return -1;
        else if (retval)
        {
            if(FD_ISSET(sockfd, &rset))
                return ::recv(sockfd, buff, nbytes, flags);
            else
                return 0;
        }
        else
            return 0;
    }
}

int YFY_Tcp_Socket::send(const void * buff, unsigned int nbytes, int flags)
{
    return ::send(_sockfd, buff, nbytes, flags);
}

int YFY_Tcp_Socket::readv(const struct iovec * iov, int iovcnt, YFY_Time_Value *timeout/* = 0*/)
{
    int sockfd;
    int retval;
    socklen_t len;
    fd_set rset;
    struct timeval tvalue;

    sockfd = _sockfd;
    if(!timeout)
        return ::readv(sockfd, iov, iovcnt);
	
    else
    {
        FD_ZERO(&rset);
        FD_SET(sockfd, &rset);
		
        tvalue.tv_sec = timeout->getSec();
        tvalue.tv_usec = timeout->getUsec();

        retval= select(sockfd + 1, &rset, NULL, NULL, &tvalue);
        if (retval == -1)
            return -1;
        else if (retval)
        {
            if(FD_ISSET(sockfd, &rset))
                return  ::readv(sockfd, iov, iovcnt);
            else
                return 0;
        }
        else
            return 0;
    }
}

int YFY_Tcp_Socket::writev(const struct iovec * iov, int iovcnt)
{
    return ::writev(_sockfd, iov, iovcnt);
}

int YFY_Tcp_Socket::recvMsg(struct msghdr * msg, int flags, YFY_Time_Value *timeout/* = 0*/)
{
    int sockfd;
    int retval;
    socklen_t len;
    fd_set rset;
    struct timeval tvalue;

    sockfd = _sockfd;
    if(!timeout)
        return ::recvmsg(sockfd, msg,flags);
    else
    {
        FD_ZERO(&rset);
        FD_SET(sockfd, &rset);
		
        tvalue.tv_sec = timeout->getSec();
        tvalue.tv_usec = timeout->getUsec();

        retval= select(sockfd + 1, &rset, NULL, NULL, &tvalue);
        if (retval == -1)
            return -1;
        else if (retval)
        {
            if(FD_ISSET(sockfd, &rset))
                return  ::recvmsg(sockfd, msg,flags);
            else
                return 0;
        }
        else
            return 0;
    }
}

int YFY_Tcp_Socket::sendMsg(struct msghdr * msg, int flags)
{
    return ::sendmsg(_sockfd, msg, flags);
}

#ifndef _YFY_UDP_SOCKET_H
#define _YFY_UDP_SOCKET_H

#include "YFY_Socket.h"
#include "YFY_Time_Value.h"
#include "YFY_Addr.h"

class YFY_Udp_Socket:public YFY_Socket
{
public:
    YFY_Udp_Socket();
    ~YFY_Udp_Socket();
    int readv(const struct iovec *iov, int iovcnt , YFY_Time_Value *timeout = 0);
    int writev(const struct iovec *iov, int iovcnt);
    int recvFrom(void *buf, size_t len, int flags, YFY_Addr *src_addr);
    int sendTo(const void *buf, size_t len, int flags, YFY_Addr *dest_addr);
};
#endif

#include "../inc/YFY_Udp_Socket.h"

YFY_Udp_Socket::YFY_Udp_Socket()
{
}

YFY_Udp_Socket::~YFY_Udp_Socket()
{
}

int YFY_Udp_Socket::readv(const struct iovec *iov, int iovcnt , YFY_Time_Value *timeout/* = 0*/)
{
    int sockfd;
    int retval;
    socklen_t len;
    fd_set rset;
    struct timeval tvalue;

    sockfd = _sockfd;
    if(!timeout)
        return ::readv(sockfd, iov, iovcnt);
	
    else
    {
        FD_ZERO(&rset);
        FD_SET(sockfd, &rset);
		
        tvalue.tv_sec = timeout->getSec();
        tvalue.tv_usec = timeout->getUsec();

        retval= select(sockfd + 1, &rset, NULL, NULL, &tvalue);
        if (retval == -1)
            return -1;
        else if (retval)
        {
            if(FD_ISSET(sockfd, &rset))
                return  ::readv(sockfd, iov, iovcnt);
            else
                return 0;
        }
        else
            return 0;
    }
}

int YFY_Udp_Socket::writev(const struct iovec * iov, int iovcnt)
{
    return ::writev(YFY_Socket::_sockfd, iov, iovcnt);
}

int YFY_Udp_Socket::recvFrom(void *buf, size_t len, int flags, YFY_Addr *src_addr)
{
    unsigned int addrlen = src_addr->getSize();
    return ::recvfrom(_sockfd, buf, len, flags, src_addr->convert(), &addrlen);
}

int YFY_Udp_Socket::sendTo(const void *buf, size_t len, int flags, YFY_Addr *dest_addr)
{
    return ::sendto(_sockfd, buf, len, flags, dest_addr->convert(), dest_addr->getSize());
}

#ifndef _YFY_TIME_VALUE_H
#define _YFY_TIME_VALUE_H

class YFY_Time_Value
{
public:
    YFY_Time_Value(unsigned int sec = 0, unsigned int usec = 0);
    ~YFY_Time_Value();
    unsigned int getSec();
    unsigned int getUsec();
    void setSec(unsigned int sec);
    void setUsec(unsigned int usec);
	
public:
    unsigned int _sec;
    unsigned int _usec;
};
#endif

#include "../inc/YFY_Time_Value.h"

YFY_Time_Value::YFY_Time_Value(unsigned int sec/* = 0*/, unsigned int usec/* = 0*/)
{
    _sec = sec;
    _usec = usec;
}

YFY_Time_Value::~YFY_Time_Value()
{
}

unsigned int YFY_Time_Value::getSec()
{
    return _sec;
}

unsigned int YFY_Time_Value::getUsec()
{
    return _usec;
}

void YFY_Time_Value::setSec(unsigned int sec)
{
    _sec = sec;
}

void YFY_Time_Value::setUsec(unsigned int usec)
{
    _usec = usec;
}



#include "YFY_Client.h"
#include <stdio.h>

int main(int argc, char * argv[])
{
    YFY_Tcp_Socket peer;
    YFY_Sock_Connector connector;
    YFY_Addr peer_addr;
    char message[200];
    int n;

    peer_addr.setIp("hostname");
    peer_addr.setPort(DEFAULT_PORT);

    if(0 == connector.connect(peer_addr, peer))
    {
        n = peer.recv(message, 200,  0);
        printf("%s\n", message);
        peer.send("my name is YFY_Client", strlen("my name is YFY_Client"),  0);
        peer.close();
    }
}

#include "YFY_Server.h"
#include <stdio.h>

int main(int argc, char *argv[])
{
    YFY_Addr server_addr;
    YFY_Sock_Acceptor acceptor;
    YFY_Tcp_Socket *peer;
    YFY_Tcp_Socket serv_sock;
    char message[200];
    int optval = 1;
    int optlen = sizeof(optval);

    server_addr.setIp("hostname");
    server_addr.setPort(DEFAULT_PORT);

    serv_sock.setOption(SOL_SOCKET, SO_REUSEADDR, &optval, optlen);
    acceptor.setSocket(&serv_sock);
	
    if(acceptor.open(&server_addr))
    {
        printf("bind or listen error\n");
        return 0;
    }
    if(peer = acceptor.accept())
    {
        peer->send("welcome to server", strlen("welcome to server"),  0);
        peer->recv(message, 200,  0);
        peer->close();
    }
}



































                

        

        

    

  


    

      

        

            

              
                
                  youfangyuan
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
c++ tcp 封装_TCP编程

				
			

			

				

					weixin_33173126的博客
				

				

					12-26
					
					961
					
				

			

		

		

			
				
API ----网络编程 ----InetAddress类 ----标准输入输出流 ----Socket类 ----ServerSocket类 TCP编程速查速记：Socket和ServerSocket
建立客户端和服务器端
建立连接后，通过Socket中的IO流进行数据的传输
关闭socket
同样，客户端与服务器端是两个独立的应用程序。客户端思路及主要代码1:建立客户端的Socket服务,并明...

			
		

	



                

              
                



	

		

			

				
					
C++网络编程笔记1

				
			

			

				

					08-08
				

			

		

		

			
				
本篇笔记将深入探讨ACE库在C++网络编程中的应用和设计思路。  首先，我们来理解什么是ACE库。ACE是一个开源的C++框架，由Douglas C. Schmidt领导的团队开发，它提供了一组用于构建分布式和网络软件的可移植组件。ACE...

			
		

	



                


  
              

                


	

		

			

				
					
C++读书笔记

				
			

			

				

					Pandaria的专栏
				

				

					11-21
					
					439
					
				

			

		

		

			
				
C陷阱和缺陷
1.赋值

			
		

	





	

		

			

				
					
FileDescriptor的作用

				
			

			

				

					angji2879的博客
				

				

					04-16
					
					612
					
				

			

		

		

			
				
一、FileDescriptor



  文件描述符类的实例用作与基础机器有关的某种结构的不透明句柄，该结构表示开放文件、开放套接字或者字节的另一个源或接收者。文件描述符的主要实际用途是创建一个包含该结构的 FileInputStream 或 FileOutputStream。




二、静态标准文件描述符



(1)标准文件描述符
...

			
		

	



		

			
		



	

		

			

				
					
c语言学习经验

				
			

			

				

					tjltail的专栏
				

				

					08-06
					
					1099
					
				

			

		

		

			
				
1.#include"stdio.h"   #include上次在网络教室上看到有人问这个问题 ""link的时候首先在相对路径下找.h,找不到然后在到path里面找,而2 宏使用问题宏替换一般在编译前,所以没有分配任何的空间,没有任何的类型可言,同时他是直接替换宏标号,所以使用一定要小心,有些人过分的喜欢用宏,其实宏的使用也不是越多越好,要防止代码的膨胀,现在的操作系统基本都是页式管理,

			
		

	





	

		

			

				
					
C++网络编程学习：源码的封装

				
			

			

				

					这里是河边
				

				

					01-26
					
					1810
					
				

			

		

		

			
				
网络编程学习记录

使用的语言为C/C++
源码支持的平台为：Windows / Linux

笔记一：建立基础TCP服务端/客户端  点我跳转
笔记二：网络数据报文的收发  点我跳转
笔记三：升级为select网络模型  点我跳转
笔记四：跨平台支持Windows、Linux系统  点我跳转
笔记五：源码的封装

笔记五网络编程学习记录一、为何要进行封装操作二、封装的思路与相关1.封装的头文件选择2.客户端类的封装3.服务端类的封装三、封装后的详细源码及其注释1.客户端TcpClient.hppclien

			
		

	





	

		

			

				
					
【C++】黑马程序员-C++核心编程学习笔记

				
			

			

				

					qq_62361050的博客
				

				

					11-08
					
					2218
					
				

			

		

		

			
				
根据黑马程序员C++课程内容，结合讲义，将自己学习C++的过程中将自己觉得有必要记下的笔记进行整理，方便复习回顾，编程环境为VSCode。本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。C++程序在执行时，将内存大方向划分为4个区域内存四区意义：不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域​ 代码区：​ 存放 CPU 执行的机器指令代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份

			
		

	





	

		

			

				
					
《C++高并发服务器笔记——第四章Linux网络编程》

				
			

			

				

					z2812470857的博客
				

				

					04-14
					
					1421
					
				

			

		

		

			
				
《C++高并发服务器笔记——第四章Linux网络编程》



			
		

	





	

		

			

				
					
【读书笔记】《高质量C/C++编程指南》

				
			

			

				

					phoenixFlyzzz的博客
				

				

					06-12
					
					2622
					
				

			

		

		

			
				
文件结构、程序版式、命名规则、表达式与基本语句、常量、函数设计、内存管理、C++高级特性

			
		

	





	

		

			

				
					
C++ 核心编程 学习笔记

				
			

			

				

					05-11
				

			

		

		

			
				
### C++核心编程学习笔记知识点概述  #### 一、内存分区模型  在C++中，内存被分为四个主要部分：代码区、全局区、...这些概念是理解和使用C++编程语言的基础。深入掌握这些内容对于成为一位熟练的C++开发者至关重要。

			
		

	





	

		

			

				
					
C++网络编程学习笔记[借鉴].pdf

				
			

			

				

					10-11
				

			

		

		

			
				
本资源摘要信息主要总结了C++网络编程学习笔记的关键知识点，涵盖了网络基础知识、OSI七层模型、TCP/IP协议、套接字编程、DNS解析、数据封装、网络字节顺序等方面的内容。  一、网络基础知识  * IP地址：逻辑地址，...

			
		

	





	

		

			

				
					
c++网络编程学习笔记

				
			

			

				

					05-05
				

			

		

		

			
				
### C++网络编程学习笔记  #### 一、网络基础概念  1. **IP地址**：在互联网中的每一台计算机都有一个独一无二的IP地址，它是一个逻辑地址，用于在网络中唯一标识一台设备。IPv4地址由四个字节组成，通常表示为四个...

			
		

	





	

		

			

				
					
C++编程规范 Google 中文版
C++编程规范 自建笔记

					
最新发布

				
			

			

				

					05-29
				

			

		

		

			
				
《C++编程规范》是Google公司为C++程序员制定的一套详细且严谨的编码标准，旨在提高代码质量、可读性、可维护性和团队协作效率。这份中文版结合了Google的实践经验，为开发者提供了丰富的编程指导，是每一位C++...

			
		

	





	

		

			

				
					
ACE_Thread_Manager

				
			

			

				

					
				

				

					04-22
					
					1994
					
				

			

		

		

			
				
ACE_INLINE
ACE_At_Thread_Exit::ACE_At_Thread_Exit (void)
  : next_ (0),
    td_ (0),
    was_applied_ (false),
    is_owner_ (true)
{
}

ACE_INLINE bool
ACE_At_Thread_Exit::was_applied() const
{
   re

			
		

	





	

		

			

				
					
ACE_Service_Object && ACE_Task_Base && ACE_Task

				
			

			

				

					
				

				

					04-21
					
					1204
					
				

			

		

		

			
				
/**
 * @class ACE_Service_Object
 *
 * @brief Provide the abstract base class common to all service
 * implementations.
 *
 * Classes that inherit from ACE_Service_Objects are capable
 * of being regi

			
		

	





	

		

			

				
					
ACE_Thread_Manager示例

				
			

			

				

					
				

				

					04-22
					
					822
					
				

			

		

		

			
				
// Test out the group management mechanisms provided by the
// ACE_Thread_Manager, including the group signal handling, group
// suspension and resumption, and cooperative thread cancellation
// mecha

			
		

	





	

		

			

				
					
C++网络编程读书笔记1—总体架构

				
			

			

				

					
				

				

					08-31
					
					556
					
				

			

		

		

			
				
C++网络编程读书笔记1
本博客中大部分内容采用思维导图的形式给出，并配备程序实例，文字说明比较少，希望能和大家一起探讨！

			
		

	





	

		

			

				
					
C++面向对象编程学习笔记：从Clock到Car类的探索

				
			

			

				

					
				

			

		

		

			
				
"面向对象编程是C++的核心特性，通过类和对象的概念，C++提供了数据封装、继承和多态等机制。在这个学习笔记中，我们将深入理解这些概念以及C++与C语言之间的关系。  首先，C++是由比雅尼·斯特劳斯特鲁普博士在1979...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值