makefile编写、GDB调试、so库文件生成

最新推荐文章于 2025-07-01 14:15:20 发布
最新推荐文章于 2025-07-01 14:15:20 发布
阅读量3.9k 收藏 2
点赞数 1
分类专栏： 工具 文章标签： makefile gdb 调试 库
本文档提供了Makefile的基础构建技巧及GDB调试工具的深入应用教程，涵盖多文件目录构建、调试符号表处理、多线程调试、条件断点设置等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

多文件目录makefile：http://www.cnblogs.com/Shirlies/p/4282182.html

层级目录makefile ：http://blog.youkuaiyun.com/hmsiwtv/article/details/20905177

makefile模板一

.SUFFIXES:.c .o  //.c和.o建立关联


CC=gcc
SRCS=hello.c\
        add.c  //同时编译两个.c文件

OBJS=$(SRCS:.c=.o)//ORJS=hello.o add.o
EXEC=hello

start: $(OBJS)  //依赖hello.o add.o
        $(CC) -o $(EXEC) $(OBJS)
        @echo '----------------ok------------'

.c.o:
        $(CC) -Wall -g -o $@ -c $<   //自动根据$(OBJS) 中.o的数量循环编译, 直到编译完所有的.c文件；； 加-g 调试

clean:

        rm -f $(OBJS)


-----------------------------------------------------------------------------------------------

1.gcc 在编译时（-c的时候）加上 -g 参数就是加入调试信息

$(CC) -Wall -g -o $@ -c $< 

-g 放在 -o 前面或者最后面

-Wall 表示提示警告

----------------------------------------------------------------------------------------------

-Wall// 大部分警告 
-Wextra // 一些额外的警告，如未使用的参数
 -Werror // 当出现警告时转为错误，停止编译
 -Wconversion // 一些可能改变值的隐式转换，给出警告。
 -Wno-unused-parameter // 函数中出现未使用的参数，不给出警告。
 -Wold-style-cast // C风格的转换，给出警告
 -Woverloaded-virtual // 如果（重载）函数的声明（与基类虚函数同名不同参）隐藏住了基类的虚函数，就给出警告。

 -Wpointer-arith// 对函数指针或者void *类型的指针进行算术操作时给出警告
 -Wshadow // 当一个局部变量遮盖住了另一个局部变量，或者全局变量时，给出警告。
 -Wwrite-strings // 规定字符串常量的类型是const char[length],因此,把这样的地址复制给 non-const char *指针将产生警告.这些警告能够帮助你在编译期间发现企图写入字符串常量 的代码
 -march=native // 指定cpu体系结构为本地平台

-----------------------------------------------------------------------------------------------

makefile模板二

.PHONY:clean
CC=g++
CPPFLAGS=-Wall -g
BIN=echosrv_poll echocli
all:$(BIN)
%.o:%.c
$(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f *.o $(BIN)


2.调试第一种：用core文件

linux默认不生成core文件，在宿主目录下的.bashrc文件中末尾加入

ulimit -c ulimited 

保存后，执行： . .bashr ，使修改生效。

这样当执行程序出错了，会生成 core.数字 的文件

执行：gdb 执行文件名 core.数字 ；加 -q 取出gdb版权信息


第二种调试：直接在gdb中运行程序，不用corefile。

gdb 执行程序名

run

gdb中常用命令：

break [文件名:]行号

break [文件名:]函数名

info break ：查看所有断点信息

delete 断点编号

list:显示10行代码，list m,n  显示m行和n行之间的

step：单步调试进入函数

next；单步不进入函数

continue:断点后继续

return [返回值]：提前结束当前函数

print 变量名

set variable 变量名 = 值

where：打印出错的地方

----------------------------------------------------------------------------

GDB调试release

方法1:  如果现在有同一个工程构建出的Debug版和Release版可执行文件projectD和projectR，如下的命令可以帮助你把Debug版中的符号表加到Release版中，实现对Release版的调试。用发布时的原代码，在原有的编译选项上（不要改变任何编译参数，即使有"-O2"参数，也不要动），只加上"-g"选项，编译出对应的debug程序。

　　1、objcopy --only-keep-debug projectD projectsymbol.dbg #生成符号表；projectsymbol.dbg是自己命名的符号文件名

　　2、gdb -q --symbol=projectsymbol.dbg -exec=projectR #加载符号表；

　　这下在gdb中就可以看到源代码了。


方法2： 在编译发布版本时加上"-g -O2",  这样就有符号表了， 而且不影响性能。

http://blog.youkuaiyun.com/blade2001/article/details/46563805

-----------------------------------------------------------------------------

转自：http://blog.chinaunix.net/uid-26000296-id-3499802.html

一、多线程调试
1. 多线程调试,最重要的几个命令:
info threads                        查看当前进程的线程。
                                    GDB会为每个线程分配一个ID, 后面操作线程的时候会用到这个ID.
                                    前面有*的是当前调试的线程.
thread                              切换调试的线程为指定ID的线程。
break file.c:100 thread all         在file.c文件第100行处为所有经过这里的线程设置断点。
set scheduler-locking off|on|step    
      在使用step或者continue命令调试当前被调试线程的时候，其他线程也是同时执行的,
      怎么只让被调试程序执行呢？
      通过这个命令就可以实现这个需求。
         off      不锁定任何线程，也就是所有线程都执行，这是默认值。
         on       只有当前被调试程序会执行。
         step     在单步的时候，除了next过一个函数的情况
                  (熟悉情况的人可能知道，这其实是一个设置断点然后continue的行为)以外，
                  只有当前线程会执行。
thread apply ID1 ID2 command        让一个或者多个线程执行GDB命令command
thread apply all command            让所有被调试线程执行GDB命令command。

2. 使用示例:
线程产生通知：在产生新的线程时, gdb会给出提示信息
(gdb) r
Starting program: /root/thread 
[New Thread 1073951360 (LWP 12900)] 
[New Thread 1082342592 (LWP 12907)]---以下三个为新产生的线程
[New Thread 1090731072 (LWP 12908)]
[New Thread 1099119552 (LWP 12909)]

查看线程：使用info threads可以查看运行的线程。
(gdb) info threads
  4 Thread 1099119552 (LWP 12940)   0xffffe002 in ?? ()
  3 Thread 1090731072 (LWP 12939)   0xffffe002 in ?? ()
  2 Thread 1082342592 (LWP 12938)   0xffffe002 in ?? ()
* 1 Thread 1073951360 (LWP 12931)   main (argc=1, argv=0xbfffda04) at thread.c:21
(gdb)
注意，行首为gdb分配的线程ID号，对线程进行切换时，使用该ID号码。
另外，行首的星号标识了当前活动的线程
切换线程：
使用 thread THREADNUMBER 进行切换，THREADNUMBER 为上文提到的线程ID号。
下例显示将活动线程从 1 切换至 4。
(gdb) info threads
   4 Thread 1099119552 (LWP 12940)   0xffffe002 in ?? ()
   3 Thread 1090731072 (LWP 12939)   0xffffe002 in ?? ()
   2 Thread 1082342592 (LWP 12938)   0xffffe002 in ?? ()
* 1 Thread 1073951360 (LWP 12931)   main (argc=1, argv=0xbfffda04) at thread.c:21
(gdb) thread 4
[Switching to thread 4 (Thread 1099119552 (LWP 12940))]#0   0xffffe002 in ?? ()
(gdb) info threads
* 4 Thread 1099119552 (LWP 12940)   0xffffe002 in ?? ()
   3 Thread 1090731072 (LWP 12939)   0xffffe002 in ?? ()
   2 Thread 1082342592 (LWP 12938)   0xffffe002 in ?? ()
   1 Thread 1073951360 (LWP 12931)   main (argc=1, argv=0xbfffda04) at thread.c:21
(gdb)
以上即为使用gdb提供的对多线程进行调试的一些基本命令。
另外，gdb也提供对线程的断点设置以及对指定或所有线程发布命令的命令

二、调试宏
在GDB下, 我们无法print宏定义，因为宏是预编译的。
但是我们还是有办法来调试宏，这个需要GCC的配合。
在GCC编译程序的时候，加上
  -ggdb3   参数，这样，你就可以调试宏了。

另外，你可以使用下述的GDB的宏调试命令 来查看相关的宏。
info macro   查看这个宏在哪些文件里被引用了，以及宏定义是什么样的。
macro         查看宏展开的样子。

三、源文件
GDB时,提示找不到源文件。
需要做下面的检查:
编译程序员是否加上了 -g参数 以包含debug信息。
路径是否设置正确了。
使用GDB的directory命令来设置源文件的目录。

下面给一个调试/bin/ls的示例(ubuntu下)
$ apt-get source coreutils
$ sudo apt-get install coreutils-dbgsym
$ gdb /bin/ls
GNU gdb (GDB) 7.1-ubuntu
(gdb) list main
1192    ls.c: No such file or directory.
in ls.c
(gdb) directory ~/src/coreutils-7.4/src/
Source directories searched: /home/hchen/src/coreutils-7.4:$cdir:$cwd
(gdb) list main
1192        }
1193    }
1194
1195    int
1196    main (int argc, char **argv)
1197    {
1198      int i;
1199      struct pending *thispend;
1200      int n_files;
1201

四、条件断点
条件断点是语法是：
  break  [where] if [condition]
这种断点真是非常管用。
尤其是在一个循环或递归中，或是要监视某个变量。
注意，这个设置是在GDB中的，只不过每经过那个断点时GDB会帮你检查一下条件是否满足。

五、命令行参数
有时候，我们需要调试的程序需要有命令行参数, 有三种方法：
gdb命令行的 -args 参数
gdb环境中   set args命令。
gdb环境中   run 参数

六、gdb的变量
有时候，在调试程序时，我们不单单只是查看运行时的变量，
我们还可以直接设置程序中的变量，以模拟一些很难在测试中出现的情况，比较一些出错，
或是switch的分支语句。使用set命令可以修改程序中的变量。
另外，你知道gdb中也可以有变量吗？
就像shell一样，gdb中的变量以$开头，比如你想打印一个数组中的个个元素，你可以这样：
(gdb) set $i = 0
(gdb) p a[$i++]
...  #然后就一路回车下去了
当然，这里只是给一个示例，表示程序的变量和gdb的变量是可以交互的。

七、x命令
也许，你很喜欢用p命令。
所以，当你不知道变量名的时候，你可能会手足无措，因为p命令总是需要一个变量名的。
x命令是用来查看内存的，在gdb中 “help x” 你可以查看其帮助。
x/x 以十六进制输出
x/d 以十进制输出
x/c 以单字符输出
x/i  反汇编 – 通常，我们会使用 x/10i $ip-20 来查看当前的汇编（$ip是指令寄存器）
x/s 以字符串输出

八、command命令
如何自动化调试。
这里向大家介绍command命令，简单的理解一下，其就是把一组gdb的命令打包，有点像字处理软件的“宏”。
下面是一个示例：
(gdb) break func
Breakpoint 1 at 0x3475678: file test.c, line 12.
(gdb) command 1
Type commands for when breakpoint 1 is hit, one per line.
End with a line saying just "end".
>print arg1
>print arg2
>print arg3
>end
(gdb)
当我们的断点到达时，自动执行command中的三个命令，把func的三个参数值打出来。

————————————————————————————————

一.编写linux下的so库文件

1.生成库文件.so

不需要main函数，但是要修改生成库函数的makefile

生成的文件名必须是 lib库名称.so  如 libmytest.so

编译时 $(CC) -Wall -g -fPIC -o $@ -c $< 

连接时 $(CC) -shared -o $(EXEC) $(OBJS)


2.so的头文件修改

要想c和c++的程序都能用你用c编写的库需要修改库函数的头文件

g++ 编译器定义了宏__cplusplus，当时c++程序调用库函数时编译会将extern "C",这样c++程序才能找到库中的函数 

#ifdef __cplusplus

extern "C"

{

#endif

函数a声明;

函数b声明;

#ifdef __cplusplus

extern "C"

}

#endif


3.外部程序调用调用库函数时，修改外部程序的makefile，在链接时 $(CC) -L库目录 -l库名称 -o $(EXEC) $(OBJS) 

c/c++基础(二十六) gdb调试so
if(...){...}
12-29 5785
当自己开发了一个so文件，如何调试呢？ 对于如何编写一个so，请参考文章：http://blog.youkuaiyun.com/zz7zz7zz/article/details/41448987 对于如何进行gdb调试，请参考文章：http://blog.youkuaiyun.com/zz7zz7zz/article/details/41654457 假设我们的源文件分别是： filea.c #include <stdio.h> void fun1() { printf("i am from filea fun1 \n");
GDB调试与makefile
x844049168的博客
06-26 1256
gdb调试命令，makefile模板
linuxGDB下动态链接库的调试
klarclm的专栏
01-15 9604
gdb) file (gdb) load                 #这条应该是可选的 (gdb) dir (gdb) sharedlibrary (gdb) breakpoint (gdb) run (gdb) info share               //查看动态库是否被引用。 load 是将动态库加载入内存。 sharedlibrary是将动态库
linux系统编程——Makefile、GDB调试
qq_46573670的博客
07-01 371
而工程也是需要被清理的。像clean这种没有被第一个目标文件直接或者间接关联，那么它后面的命令就不会被执行，所以我们可以显式要make执行，即make clean，以此来一次性清除所有生成的目标文件，以便于重新编译。makefile定义了一系列的规则来指定哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile文件就像一个shell脚本一样，也可以执行操作系统的命令。如果依赖的时间比目标的时间早，目标不需要更新，对应规则中的命令不需要被执行。
GDB的so库调试
sysedoc的博客
06-03 5642
假设在/Test目录下有一个可执行文件main以及一个lib.so库文件，同时lib.so的源代码为lib.c 现希望调试lib.so库 cd /Test # 进入目标文件夹 $GDB main # 使用GDB调试main程序 (GDB) directory /test # 指定lib.c所在路径 (GDB) b main # 在main函数处...
android so库调试gdb,gdb可以实现源码级调试so文件吗?[己解决]
weixin_30253289的博客
05-27 310
zz@ubuntu:/usr/local/usr/my_tools/alsa-lib-1.0.24.1/test/.libs$ gdb ./pcm_minGNU gdb (Ubuntu/Linaro 7.2-1ubuntu11) 7.2Copyright (C) 2010 Free Software Foundation, Inc.License GPLv3+: GNU GPL version 3...
gdb调试包含多个动态库so库的简单工程
人生虚空
09-29 3933
(一共>2个so库, libTNN.so需要librknpu_ddk.so, librknpu_ddk.so需要其他3个so库, librknpu_ddk.so和其他3个so库放一起, 在文件夹rknpu_ddk_lib64下, 即rknpu_ddk一共4个so库) 测试过程是首先通过以下命令用g++编译工程, 然后进gdb -q test_tnn进行调试 第一种 -L和-l包括rknpu_ddk和TNN, -Wl,-rpath包括rknpu_ddk 4个so库和libTNN.so的目录编译成..
【项目一】GCC（gcc，g++）、静态库、动态库、MakeFile、GDB调试
weixin_43896452的博客
06-06 1745
静态库实际上是将.c文件们打包。这些.c文件定义的函数，都在.h文件中申明。-c 生成目标代码 test.o，test.o 不是一个可执行程序。如果下一步需要继续链接成可执行程序，需要输入指令 gcc test.o -o test.out（src目录下：gcc -c add.c div.c mult.c sub.c 是要报错的，因为找不到.h文件。所以整个直接 gcc test.c 包含了预处理，编译，汇编，链接成可执行文件4步。如果gcc xx.c -o app不加-o，只有gcc xx.c。
linux下的静态库与动态库的区别,Gdb调试段错误,自动生成Makefile.pdf
12-31
Linux 静态库与动态库的区别、Gdb 调试段错误、自动生成 Makefile Linux 下的静态库与动态库的区别： 1. 库的概念：库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。 2. 库的种类：Linux下的库有两...
C++ Makefile / Cmake 构建工程 & GDB调试
yly的博客
06-05 2652
Table of Contents 一、基础知识 1.1 编译器 1.2 编译四步 1.3 链接 二、MAKE 2.1 指定头文件路径 2.2 指定链接库 2.3 编译源文件 三、CMAKE 3.1 编译源文件 3.2 加入头文件 & 链接库文件 a)加入头文件 b)引入可执行文件 c)链接库文件 3.3 生成库文件 3.4 其他常用命令 四、GDB...
Linux gcc 环境， gdb 调试 与 makefile 自动化构建
qq_61500888的博客
07-26 3683
带你一命通关 Linux 基础 十分钟手撕 Linux 底层
linux下gdb.so
12-29
gdb-so demo
linux下构建多目录下Makefile产生so动态库样例
08-08
我的工作最近需要用到linux下构建多目录下Makefile产生so动态库样例的知识，我将最新的学习心得，做一个记录分享，以便以后需要使用时可以做参考。
gdb / 调试进入 so 库的方法
布袋和尚
07-07 4372
一、准备 1、so 库源码 /* * mylib.h */ #ifndef MYLIB_H_ #define MYLIB_H_ int add(const int &i, const int &k); int cross(const int &i, const int &k); #endif /* * mylib.cc */ #include "mylib.h" int add(const int &i, const int &k) {
关于linux平台下用gdb调试so动态库
stepbystep_1_1的专栏
07-03 1万+
在linux平台下的程序写了很多，但是调试感觉不是很熟悉。这几天专门去学习了一把，搞了一下so的调试。首先给出两个源文件，即调用程序和被调用动态库程序的源代码。调用程序源代码：main.cpp#include #include #include #include int main(){    void *dlh=NULL;    int (*printmsg)(char *pMsg);  
linux gdb调试动态库(so)的方法
热门推荐
u012684933的专栏
03-04 4万+
原文地址： http://www.gonwan.com/?tag=gdb 在本例中使用了libcurl.so.4库 step1: 编译libcurl.so.4的可调试版本： # sudo apt-get source libcurl3-dbg # cd curl-7.19.7/ # ./configure --prefix=/usr/local --enable-debug --
动态库与 GDB：如何调试共享库（.so 文件）
底层软件设计内幕
11-24 1984
然而，调试动态库往往复杂，因为它们在运行时动态加载，函数符号可能未绑定，甚至部分库可能被延迟加载。动态库的调试就像乐队排练：主程序是指挥，动态库是乐器。调试动态库不仅仅是找到符号和设置断点的过程，更是深入理解程序运行时动态链接的一个机会。调试动态库，就像解开复杂的拼图——你需要找到正确的碎片，理清它们的连接关系。为了模拟调试动态库的场景，我们创建一个简单的共享库和一个调用它的主程序。动态库的符号在运行时加载，因此调试时需要检查符号是否正确加载。在现代软件开发中，动态库（共享库。，解决程序崩溃后的问题排查。
gdb调试和makefile
enjoyxiong的博客
11-30 207
一 gdb调试 前提条件：可执行文件必须包含调试信息 gcc -g 1 启动gdb：gdb 文件名 2 查找代码： 当前文件：list 行号（函数名） 指定文件：list 文件名：行号（函数名） 3 设置断点： 设置当前文件断点：b 行号（函数名） 设置指定文件断点：b 文件名：行号（函数名） 设置条件断点：b 行号 if value==23 删除断点：d 断点的编号 4 查看设置的断点：info...
GDB调试中 如何在so共享库中打断点、保存断点以及加载断点
hao1183716597的专栏
07-26 9766
最近在使用gdb的过程中，需要对so文件进行调试，在这里记录一下调试中的问题及解决方法。 如何在so源文件中打断点？ 首先编译so时需要-g指令。 在gdb xxx指令后，发现无法在so对应的源码文件中打断点，break指令找不到so中的类、源文件cpp，这里的方法就是需要在so加载进来后，就可以找到so文件的类名和源文件了，我们可以先run执行一遍，然后Ctrl+C结束，重新打断点即可找...
linux c 多文件实现客户端和服务端UDP和TCP通信 并cmake编译 makefile vscode编写调试
最新发布
08-09
<think>我们首先需要实现TCP和UDP的客户端和服务器端通信程序。然后，我们将为这些程序编写CMake和Makefile，以便在VSCode中进行编译和调试。 步骤： 1. 创建项目目录结构 2. 编写TCP和UDP的服务器和客户端代码（C语言） 3. 编写CMakeLists.txt和Makefile 4. 配置VSCode进行编写和调试 由于UDP和TCP的通信方式不同，我们将分别实现。 目录结构建议： ``` project/ ├── CMakeLists.txt ├── Makefile (可选，或者使用cmake生成的Makefile) ├── tcp/ │ ├── tcp_server.c │ └── tcp_client.c ├── udp/ │ ├── udp_server.c │ └── udp_client.c └── build/ (用于cmake构建) ``` 一、TCP通信 TCP服务器端（tcp_server.c）基本步骤： 1. 创建套接字（socket） 2. 绑定（bind）到本地地址和端口 3. 监听（listen）连接 4. 接受（accept）连接 5. 读写数据（read/write） 6. 关闭套接字 TCP客户端（tcp_client.c）基本步骤： 1. 创建套接字（socket） 2. 连接（connect）到服务器 3. 读写数据 4. 关闭套接字 二、UDP通信 UDP服务器端（udp_server.c）基本步骤： 1. 创建套接字（socket） 2. 绑定（bind）到本地地址和端口 3. 接收（recvfrom）数据 4. 发送（sendto）数据 5. 关闭套接字 UDP客户端（udp_client.c）基本步骤： 1. 创建套接字（socket） 2. 发送（sendto）数据到服务器 3. 接收（recvfrom）数据 4. 关闭套接字 三、编写CMakeLists.txt 我们将使用CMake来管理项目，这样可以在VSCode中方便地编译和调试。 四、配置VSCode 在VSCode中，我们需要配置C/C++扩展，以及CMake Tools扩展。然后配置调试环境（launch.json和tasks.json）。 由于代码较长，我们分别编写。这里先给出TCP和UDP的代码示例，然后给出CMakeLists.txt。 注意：为了简化，我们只实现基本功能，不处理错误边界情况。 1. TCP服务器端代码（tcp_server.c）: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #include <sys/socket.h> #define PORT 8080 #define BUFFER_SIZE 1024 int main() { int server_fd, new_socket; struct sockaddr_in address; int opt = 1; int addrlen = sizeof(address); char buffer[BUFFER_SIZE] = {0}; const char *hello = "Hello from TCP server"; // 创建套接字 if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) { perror("socket failed"); exit(EXIT_FAILURE); } // 设置套接字选项，允许地址重用 if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) { perror("setsockopt"); exit(EXIT_FAILURE); } address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; address.sin_port = htons(PORT); // 绑定 if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) { perror("bind failed"); exit(EXIT_FAILURE); } // 监听 if (listen(server_fd, 3) < 0) { perror("listen"); exit(EXIT_FAILURE); } printf("TCP Server listening on port %d\n", PORT); // 接受连接 if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) { perror("accept"); exit(EXIT_FAILURE); } // 读取客户端发送的数据 read(new_socket, buffer, BUFFER_SIZE); printf("Client: %s\n", buffer); // 发送响应 send(new_socket, hello, strlen(hello), 0); printf("Hello message sent\n"); // 关闭套接字 close(new_socket); close(server_fd); return 0; } ``` 2. TCP客户端代码（tcp_client.c）: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #include <sys/socket.h> #define PORT 8080 #define BUFFER_SIZE 1024 int main() { int sock = 0; struct sockaddr_in serv_addr; char *hello = "Hello from TCP client"; char buffer[BUFFER_SIZE] = {0}; // 创建套接字 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror("socket creation error"); return -1; } serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(PORT); // 将IPv4地址从字符串转换为二进制形式 if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) { perror("Invalid address/ Address not supported"); return -1; } // 连接服务器 if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { perror("Connection Failed"); return -1; } // 发送消息 send(sock, hello, strlen(hello), 0); printf("Hello message sent\n"); // 读取响应 read(sock, buffer, BUFFER_SIZE); printf("Server: %s\n", buffer); close(sock); return 0; } ``` 3. UDP服务器端代码（udp_server.c）: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #include <sys/socket.h> #define PORT 8080 #define BUFFER_SIZE 1024 int main() { int sockfd; char buffer[BUFFER_SIZE]; struct sockaddr_in servaddr, cliaddr; const char *hello = "Hello from UDP server"; // 创建套接字 if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { perror("socket creation failed"); exit(EXIT_FAILURE); } servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = INADDR_ANY; servaddr.sin_port = htons(PORT); // 绑定 if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) { perror("bind failed"); exit(EXIT_FAILURE); } printf("UDP Server listening on port %d\n", PORT); socklen_t len; int n; len = sizeof(cliaddr); // 接收数据 n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, 0, (struct sockaddr *)&cliaddr, &len); buffer[n] = '\0'; printf("Client: %s\n", buffer); // 发送响应 sendto(sockfd, (const char *)hello, strlen(hello), 0, (const struct sockaddr *)&cliaddr, len); printf("Hello message sent.\n"); close(sockfd); return 0; } ``` 4. UDP客户端代码（udp_client.c）: ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #include <sys/socket.h> #define PORT 8080 #define BUFFER_SIZE 1024 int main() { int sockfd; struct sockaddr_in servaddr; char *hello = "Hello from UDP client"; char buffer[BUFFER_SIZE] = {0}; // 创建套接字 if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { perror("socket creation failed"); exit(EXIT_FAILURE); } servaddr.sin_family = AF_INET; servaddr.sin_port = htons(PORT); servaddr.sin_addr.s_addr = INADDR_ANY; socklen_t len = sizeof(servaddr); // 发送消息 sendto(sockfd, (const char *)hello, strlen(hello), 0, (const struct sockaddr *)&servaddr, len); printf("Hello message sent.\n"); // 接收响应 int n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, 0, (struct sockaddr *)&servaddr, &len); buffer[n] = '\0'; printf("Server: %s\n", buffer); close(sockfd); return 0; } ``` 5. CMakeLists.txt 文件（放在项目根目录）: ```cmake cmake_minimum_required(VERSION 3.10) project(NetworkCommunication) # 设置C标准 set(CMAKE_C_STANDARD 11) # 添加可执行文件 add_executable(tcp_server tcp/tcp_server.c) add_executable(tcp_client tcp/tcp_client.c) add_executable(udp_server udp/udp_server.c) add_executable(udp_client udp/udp_client.c) ``` 6. 编译和运行： 在项目根目录下： ``` mkdir build cd build cmake .. make ``` 然后运行生成的可执行文件。 7. VSCode配置： 安装CMake Tools扩展后，打开项目目录，VSCode会自动检测CMakeLists.txt并提示配置。 配置调试：在VSCode中，打开调试视图，创建一个launch.json文件，选择C++ (GDB/LLDB)环境，然后为每个可执行文件配置调试目标。 例如，调试tcp_server: ```json { "name": "Debug TCP Server", "type": "cppdbg", "request": "launch", "program": "${workspaceFolder}/build/tcp_server", "args": [], "stopAtEntry": false, "cwd": "${workspaceFolder}", "environment": [], "externalConsole": false, "MIMode": "gdb", "setupCommands": [ { "description": "Enable pretty-printing for gdb", "text": "-enable-pretty-printing", "ignoreFailures": true } ], "preLaunchTask": "Build All" // 需要先定义构建任务 } ``` 在tasks.json中定义构建任务（使用CMake）： ```json { "version": "2.0.0", "tasks": [ { "label": "Build All", "type": "shell", "command": "cmake --build ${workspaceFolder}/build --config Debug" } ] } ``` 注意：在实际运行中，需要先启动服务器，再启动客户端。 以上是一个基本的实现。在实际项目中，可能需要处理更多的错误和边界情况，以及实现更复杂的通信协议。 相关问题： 1. 如何确保TCP和UDP通信的可靠性？ 2. 在CMake中如何添加依赖库（如线程库）？ 3. 如何实现多客户端的TCP服务器（使用多线程或多进程）？ 4. 如何设置VSCode的调试环境以同时调试多个程序（例如同时启动服务器和客户端）？ 5. 如何用CMake管理多个子项目？</think>### Linux C语言实现UDP/TCP通信与编译调试指南 #### 一、项目结构规划 ```bash project/ ├── CMakeLists.txt # CMake配置文件 ├── Makefile # Makefile文件 ├── tcp/ │ ├── tcp_server.c # TCP服务端 │ └── tcp_client.c # TCP客户端 ├── udp/ │ ├── udp_server.c # UDP服务端 │ └── udp_client.c # UDP客户端 └── build/ # 编译输出目录 ``` #### 二、核心代码实现 ##### 1. TCP服务端 (`tcp/tcp_server.c`) ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #define PORT 8080 #define BUFFER_SIZE 1024 int main() { int server_fd, new_socket; struct sockaddr_in address; int addrlen = sizeof(address); char buffer[BUFFER_SIZE] = {0}; // 创建TCP套接字 if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) { perror("socket failed"); exit(EXIT_FAILURE); } address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; address.sin_port = htons(PORT); // 绑定端口 if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) { perror("bind failed"); exit(EXIT_FAILURE); } // 监听连接 if (listen(server_fd, 3) < 0) { perror("listen"); exit(EXIT_FAILURE); } printf("TCP Server listening on port %d\n", PORT); // 接受连接 if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) { perror("accept"); exit(EXIT_FAILURE); } // 数据交换 read(new_socket, buffer, BUFFER_SIZE); printf("Received: %s\n", buffer); send(new_socket, "ACK from TCP Server", 19, 0); close(new_socket); close(server_fd); return 0; } ``` ##### 2. TCP客户端 (`tcp/tcp_client.c`) ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #define PORT 8080 #define BUFFER_SIZE 1024 int main() { int sock = 0; struct sockaddr_in serv_addr; char *hello = "Hello from TCP client"; char buffer[BUFFER_SIZE] = {0}; if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror("Socket creation error"); return -1; } serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(PORT); // 转换IPv4地址 if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) { perror("Invalid address"); return -1; } // 连接服务器 if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { perror("Connection Failed"); return -1; } send(sock, hello, strlen(hello), 0); printf("Message sent\n"); read(sock, buffer, BUFFER_SIZE); printf("Server: %s\n", buffer); close(sock); return 0; } ``` ##### 3. UDP服务端 (`udp/udp_server.c`) ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #define PORT 8080 #define BUFFER_SIZE 1024 int main() { int sockfd; char buffer[BUFFER_SIZE]; struct sockaddr_in servaddr, cliaddr; // 创建UDP套接字 if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { perror("socket creation failed"); exit(EXIT_FAILURE); } servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = INADDR_ANY; servaddr.sin_port = htons(PORT); // 绑定端口 if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) { perror("bind failed"); exit(EXIT_FAILURE); } printf("UDP Server listening on port %d\n", PORT); socklen_t len = sizeof(cliaddr); // 接收数据 int n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, 0, (struct sockaddr *)&cliaddr, &len); buffer[n] = '\0'; printf("Client: %s\n", buffer); // 发送响应 sendto(sockfd, "ACK from UDP Server", 19, 0, (const struct sockaddr *)&cliaddr, len); close(sockfd); return 0; } ``` ##### 4. UDP客户端 (`udp/udp_client.c`) ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <arpa/inet.h> #define PORT 8080 #define BUFFER_SIZE 1024 int main() { int sockfd; struct sockaddr_in servaddr; char *hello = "Hello from UDP client"; // 创建UDP套接字 if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { perror("socket creation failed"); exit(EXIT_FAILURE); } servaddr.sin_family = AF_INET; servaddr.sin_port = htons(PORT); servaddr.sin_addr.s_addr = INADDR_ANY; socklen_t len = sizeof(servaddr); // 发送数据 sendto(sockfd, (const char *)hello, strlen(hello), 0, (const struct sockaddr *)&servaddr, len); printf("Message sent\n"); // 接收响应 char buffer[BUFFER_SIZE]; int n = recvfrom(sockfd, (char *)buffer, BUFFER_SIZE, 0, (struct sockaddr *)&servaddr, &len); buffer[n] = '\0'; printf("Server: %s\n", buffer); close(sockfd); return 0; } ``` #### 三、编译配置 ##### 1. CMake配置 (`CMakeLists.txt`) ```cmake cmake_minimum_required(VERSION 3.10) project(NetworkCommunication) set(CMAKE_C_STANDARD 11) # TCP可执行文件 add_executable(tcp_server tcp/tcp_server.c) add_executable(tcp_client tcp/tcp_client.c) # UDP可执行文件 add_executable(udp_server udp/udp_server.c) add_executable(udp_client udp/udp_client.c) # 链接网络库 target_link_libraries(tcp_server pthread) target_link_libraries(tcp_client pthread) target_link_libraries(udp_server pthread) target_link_libraries(udp_client pthread) ``` ##### 2. Makefile配置 ```makefile CC = gcc CFLAGS = -Wall -Wextra -pthread TARGETS = tcp_server tcp_client udp_server udp_client all: $(TARGETS) tcp_server: tcp/tcp_server.c $(CC) $(CFLAGS) -o $@ $^ tcp_client: tcp/tcp_client.c $(CC) $(CFLAGS) -o $@ $^ udp_server: udp/udp_server.c $(CC) $(CFLAGS) -o $@ $^ udp_client: udp/udp_client.c $(CC) $(CFLAGS) -o $@ $^ clean: rm -f $(TARGETS) ``` #### 四、VSCode调试配置 1. **安装扩展**： - C/C++ (Microsoft) - CMake Tools (Microsoft) - CodeLLDB (可选) 2. **调试配置 (`launch.json`)**： ```json { "version": "0.2.0", "configurations": [ { "name": "Debug TCP Server", "type": "cppdbg", "request": "launch", "program": "${workspaceFolder}/build/tcp_server", "args": [], "cwd": "${workspaceFolder}", "environment": [], "externalConsole": false, "MIMode": "gdb" }, { "name": "Debug TCP Client", "type": "cppdbg", "request": "launch", "program": "${workspaceFolder}/build/tcp_client", "args": [], "cwd": "${workspaceFolder}", "environment": [], "externalConsole": false, "MIMode": "gdb" } ] } ``` 3. **编译和调试步骤**： ```bash mkdir build && cd build cmake .. -DCMAKE_BUILD_TYPE=Debug make # 在VSCode中按F5启动调试 ``` #### 五、通信测试流程 1. **TCP测试**： ```bash # 终端1：启动服务端 ./build/tcp_server # 终端2：启动客户端 ./build/tcp_client ``` 2. **UDP测试**： ```bash # 终端1：启动服务端 ./build/udp_server # 终端2：启动客户端 ./build/udp_client ``` #### 六、调试技巧 1. **网络调试工具**： - 使用 `tcpdump` 抓包分析：`sudo tcpdump -i lo port 8080` - 使用 Wireshark 可视化分析[^1] 2. **常见错误处理**： - `Address already in use`：使用 `SO_REUSEADDR` 套接字选项 - 连接超时：检查防火墙设置 `sudo ufw allow 8080` - 数据截断：验证缓冲区大小和MTU设置 > **注意**：TCP是面向连接的可靠传输，UDP是无连接的快速传输，选择取决于应用场景[^1]。 --- ### 相关问题 1. 如何实现多客户端的TCP服务器（使用多线程或多进程）？ 2. CMake中如何添加第三方网络库（如libevent）？ 3. 如何用Wireshark分析TCP三次握手和UDP数据包？ 4. 在VSCode中如何配置跨文件调试（同时调试客户端和服务端）？ 5. 如何实现超时重传机制提升UDP的可靠性？ [^1]: 与其他IPC相比，TCP协议的可记录性使其更易调试 [^2]: 编译时建议使用 `make -j` 加速编译过程 [^3]: Linux C++后端开发需要系统学习网络编程知识
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值