C++；GCC的库问题 我对C++是全新的，但是我有很多编程的经验，所以我对大多数低级概念很熟悉。

无论如何，我想我应该尝试编写一个IRC客户端，因为IRC似乎有一个相对简单的TCP协议。（这很简单，你可以通过Telnet访问和使用服务器，这不现实，但可行）

所以我在谷歌上搜索了“C++套接字库”，发现了一个包含一些套接字支持的通用库

我查看了文档，找到了一个示例，该示例应与它接收到的任何内容相呼应，并尝试对其进行编译。 但是，关于函数的“未定义引用”，我有很多错误

我真的不知道现在该怎么办。 谁能给我一些建议吗

我在代码：：Blocks v10.05和GCC 4.4.1中构建了这个 （我会使用4.6.1，但我还没有弄清楚如何让Code:：Blocks以这种方式编译）

下面是一个确切的例子：

// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
/*

    This is an example illustrating the use of the sockets and
    server components from the dlib C++ Library.

    This is a simple echo server.  It listens on port 1234 for incoming
    connections and just echos back any data it receives.

*/




#include "dlib/sockets.h"
#include "dlib/server.h"
#include "dlib/ref.h" // for ref()
#include <iostream>

using namespace dlib;
using namespace std;



class serv : public server::kernel_1a_c
{

    void on_connect  (
        connection& con
    )
    {
        char ch;
        while (con.read(&ch,1) > 0)
        {
            // we are just reading one char at a time and writing it back
            // to the connection.  If there is some problem writing the char
            // then we quit the loop.
            if (con.write(&ch,1) != 1)
                break;
        }
    }

};


void thread(serv& our_server)
{
    try
    {
        // Start the server.  start() blocks until the server is shutdown
        // by a call to clear()
        our_server.start();
    }
    catch (socket_error& e)
    {
        cout << "Socket error while starting server: " << e.what() << endl;
    }
    catch (exception& e)
    {
        cout << "Error while starting server: " << e.what() << endl;
    }
}


int main()
{
    try
    {
        serv our_server;

        // set up the server object we have made
        our_server.set_listening_port(1234);
        our_server.set_max_connections(1000);

        // create a thread that will start the server.   The ref() here allows us to pass
        // our_server into the threaded function by reference.
        thread_function t(thread, dlib::ref(our_server));

        cout << "Press enter to end this program" << endl;
        cin.get();
        // this will cause the server to shut down
        our_server.clear();
    }
    catch (exception& e)
    {
        cout << e.what() << endl;
    }
    catch (...)
    {
        cout << "Some error occurred" << endl;
    }
}

//此文件的内容位于公共域中。请参阅许可证，以获取\u示例\u PROGRAMS.txt
/*
这是一个示例，说明了套接字和
DLIB C++库中的服务器组件。
这是一个简单的echo服务器。它在端口1234上侦听传入数据
连接，只是回显它接收到的任何数据。
*/
#包括“dlib/sockets.h”
#包括“dlib/server.h”
#包括“dlib/ref.h”//for ref（）
#包括
使用名称空间dlib；
使用名称空间std；
类服务：公共服务器：：内核
{
连接时无效(
连接与控制
)
{
char ch；
而（con.read（&ch，1）>0）
{
//我们只是一次读一个字符，然后写回来
//连接。如果写入字符时出现问题
//然后我们退出循环。
if（con.write（&ch，1）！=1）
打破
}
}
};
无效线程（服务和我们的服务器）
{
尝试
{
//启动服务器。Start（）会一直阻塞，直到服务器关闭
//通过呼叫清除（）
我们的_server.start（）；
}
捕获（套接字错误&e）
{
cout看起来您缺少告诉gcc与dlib库链接的选项。我不知道对Code:：Blocks的具体设置是什么，但一般来说，对于gcc，您需要使用-l选项，如下所示：

gcc-ldlib

使现代化
好的，我对此进行了更好的研究，看起来dlib实际上并没有为您构建库。外部库包工作的常见方式是提供一个生成文件，用于构建您需要链接的*.a或*.so文件。但是dlib没有提供这一功能，需要您将其特殊的
source.cpp
添加到您的build设置。同样，我不知道如何在代码块中执行此操作，但在编译和链接该套接字示例时，以下内容对我有用：

g++-o dlib_socket-I../dlib-17.42/-lpthread-lX11 dlib_socket.cpp../dlib-17.42/dlib/all/source.cpp

在上面的示例中，我将dlib提取到父目录中（因此是../dlib-17.42/dlib）
看起来您缺少告诉gcc链接dlib库的选项。我不知道Code:：Blocks的具体设置是什么，但一般来说，对于gcc，您需要使用-l选项，如下所示：

gcc-ldlib

使现代化
好的，我对此进行了更好的研究，看起来dlib实际上并没有为您构建库。外部库包工作的常见方式是提供一个生成文件，用于构建您需要链接的*.a或*.so文件。但是dlib没有提供这一功能，需要您将其特殊的
source.cpp
添加到您的build设置。同样，我不知道如何在代码块中执行此操作，但在编译和链接该套接字示例时，以下内容对我有用：

g++-o dlib_socket-I../dlib-17.42/-lpthread-lX11 dlib_socket.cpp../dlib-17.42/dlib/all/source.cpp

在上面的示例中，我将dlib提取到父目录中（因此是../dlib-17.42/dlib）
您最好不要使用C:：B。尝试NetBeans，因为它将生成make文件

右键单击项目并转到“生成选项”。在那里您将找到链接器。从那里添加库

最好不要使用C:：B。试试NetBeans，因为它会生成make文件

右键单击项目并转到“生成选项”。在那里您将找到链接器。从那里添加库

最前面和最前面
告诉您关于套接字编程需要了解的一切。
在你理解基本知识之前就跳进图书馆对套接字来说是适得其反的。
大多数套接字库都是简单的包装器，可以为您处理数据结构

这是我几年前为windows编写的一个类

#pragma once
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
class cMySocket {
public:
    cMySocket(void);
    ~cMySocket(void);

    int startup_server(int type, unsigned __int16 port, const char* ip );
    void shutdown_server();
    operator SOCKET();
    cMySocket & operator=(const SOCKET &s);

    bool           running;
    SOCKET         m_socket;
    sockaddr_in    service;
    sockaddr_in    client_addr;
};
cMySocket::cMySocket(void){
    m_socket = SOCKET_ERROR;
    running = false;
}

cMySocket::~cMySocket(void){
    if( m_socket != SOCKET_ERROR )
        closesocket(m_socket);
}

int cMySocket::startup_server(int type, unsigned __int16 port, const char* ip ){
    unsigned long iMode = 1;

    m_socket = socket(AF_INET, type, 0);
    if (m_socket == INVALID_SOCKET){
        throw "Error at socket()\n";
    }

    if( ioctlsocket(m_socket, FIONBIO, &iMode) == SOCKET_ERROR){
        closesocket(m_socket);
        throw "Error at ioctlsocket()\n";
    }

    memset( &service, 0, sizeof( service ));
    service.sin_family = AF_INET;
    service.sin_addr.s_addr = inet_addr(ip);
    service.sin_port = htons(port);

    if( bind(m_socket, (SOCKADDR*)&service, sizeof(service)) == SOCKET_ERROR ){
        closesocket(m_socket);
        throw "Error at bind()\n";
    }
    iMode = 1;
    if ( ioctlsocket( m_socket, FIONBIO, &iMode ) )
    {
        closesocket(m_socket);
        throw "Error at iostlcosket()\n";
    }
    if( type == SOCK_STREAM ){
        if( listen( m_socket, 10) == SOCKET_ERROR ){
            closesocket(m_socket);
            throw "Error at listen()\n";
        }
    }
    running = true;
    return 1;
}

void cMySocket::shutdown_server(){
    closesocket( m_socket );
    m_socket = SOCKET_ERROR;
    running = false;
}

cMySocket::operator SOCKET () { 
    return m_socket; 
}

cMySocket & cMySocket::operator=(const SOCKET &s){  
    m_socket = s;
    return *this;
}

#pragma一次
#包括
#pragma注释（lib，“ws2_32.lib”）
cMySocket类{
公众：
cMySocket（无效）；
~cMySocket（无效）；
int启动\u服务器（int类型，无符号\u int16端口，常量字符*ip）；
无效关闭服务器（）；
运算符套接字（）；
cMySocket和操作符=（const SOCKET和s）；
布尔跑；
插座m_插座；
正在使用的sockaddr_；
客户机地址中的sockaddr\u；
};
cMySocket:：cMySocket（void）{
m_socket=socket_错误；
运行=错误；
}
cMySocket:：~cMySocket（void）{
if（m_socket！=socket_错误）
闭合插座（m_插座）；
}
int cMySocket:：startup_服务器（int类型，无符号_int16端口，常量字符*ip）{
无符号长iMode=1；
m_socket=插座（AF INET，类型，0）；
if（m_socket==无效的_socket）{
抛出“套接字错误（）\n”；
}
if（ioctlsocket（m_套接字、FIONBIO和iMode）=套接字错误）{
闭合插座（m_插座）；
抛出“ioctlsocket（）出错\n”；
}
memset（&service，0，sizeof（service））；
service.sinu family=AF\u INET；
service.sin\u addr.s\u addr=inet\u addr（ip）；
service.sin_port=htons（port）；
如果（绑定）（mu so
#pragma once
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
class cMySocket {
public:
    cMySocket(void);
    ~cMySocket(void);

    int startup_server(int type, unsigned __int16 port, const char* ip );
    void shutdown_server();
    operator SOCKET();
    cMySocket & operator=(const SOCKET &s);

    bool           running;
    SOCKET         m_socket;
    sockaddr_in    service;
    sockaddr_in    client_addr;
};
cMySocket::cMySocket(void){
    m_socket = SOCKET_ERROR;
    running = false;
}

cMySocket::~cMySocket(void){
    if( m_socket != SOCKET_ERROR )
        closesocket(m_socket);
}

int cMySocket::startup_server(int type, unsigned __int16 port, const char* ip ){
    unsigned long iMode = 1;

    m_socket = socket(AF_INET, type, 0);
    if (m_socket == INVALID_SOCKET){
        throw "Error at socket()\n";
    }

    if( ioctlsocket(m_socket, FIONBIO, &iMode) == SOCKET_ERROR){
        closesocket(m_socket);
        throw "Error at ioctlsocket()\n";
    }

    memset( &service, 0, sizeof( service ));
    service.sin_family = AF_INET;
    service.sin_addr.s_addr = inet_addr(ip);
    service.sin_port = htons(port);

    if( bind(m_socket, (SOCKADDR*)&service, sizeof(service)) == SOCKET_ERROR ){
        closesocket(m_socket);
        throw "Error at bind()\n";
    }
    iMode = 1;
    if ( ioctlsocket( m_socket, FIONBIO, &iMode ) )
    {
        closesocket(m_socket);
        throw "Error at iostlcosket()\n";
    }
    if( type == SOCK_STREAM ){
        if( listen( m_socket, 10) == SOCKET_ERROR ){
            closesocket(m_socket);
            throw "Error at listen()\n";
        }
    }
    running = true;
    return 1;
}

void cMySocket::shutdown_server(){
    closesocket( m_socket );
    m_socket = SOCKET_ERROR;
    running = false;
}

cMySocket::operator SOCKET () { 
    return m_socket; 
}

cMySocket & cMySocket::operator=(const SOCKET &s){  
    m_socket = s;
    return *this;
}