0
点赞
收藏
分享

微信扫一扫

C语言编程答疑之动态甜甜圈-AI辅助版-

witmy 2024-11-12 阅读 8
c语言开发语言#include字符数组变量声明JavaScript前端开发


非常感谢一直以来留言反馈的各位朋友。

C语言编程答疑之动态甜甜圈-AI辅助版-_#include

由于消息非常多，工作任务非常重，部分消息不能及时回复，非常抱歉。

C语言编程答疑之动态甜甜圈-AI辅助版-_#include_02

 

代码和运行系统平台。Win、Linux。

用C++写一个简单的动态甜甜圈吧字符串显示的那种哦_c语言画甜甜圈

合适的提问。

1. 将这段C++代码修改为C语言版本。

2. 修改为Linux C

3. 给出全部代码不要省略

4. 处理出错修正

C语言编程答疑之动态甜甜圈-AI辅助版-_字符数组_03

C语言编程答疑之动态甜甜圈-AI辅助版-


 

gcc donut.c -lm -o donut

donut.c如下linux：

#include <stdio.h>  
#include <math.h>  
#include <string.h>  
#include <unistd.h>  
  
int main() {  
    float A = 0, B = 0; // 这两个变量将随时间变化  
    float i, j; // 用于循环中的角度计算  
    int k; // 用于遍历数组和打印字符  
    float z[1760]; // 用于存储每个屏幕位置的最大深度值  
    char b[1760]; // 用于存储要打印的字符  
  
    // 清屏  
    printf("\x1b[2J");  
  
    for (;;) { // 无限循环  
        // 使用sizeof来确保正确的内存大小被清零  
        memset(b, 32, sizeof(b)); // 用空格填充字符数组  
        memset(z, 0, sizeof(z));  // 将浮点数组清零  
  
        // 计算并更新字符数组b和深度数组z  
        for (j = 0; j < 6.28; j += 0.07) { // j是垂直方向的角度  
            for (i = 0; i < 6.28; i += 0.02) { // i是水平方向的角度  
                float c = sin(i);  
                float d = cos(j);  
                float e = sin(A);  
                float f = sin(j);  
                float g = cos(A);  
                float h = d + 2;  
                float D = 1 / (c * h * e + f * g + 5); // 计算深度  
  
                float l = cos(i);  
                float m = cos(B);  
                float n = sin(B);  
                float t = c * h * g - f * e;  
  
                // 计算屏幕上的x和y坐标  
                int x = 40 + 30 * D * (l * h * m - t * n);  
                int y = 12 + 15 * D * (l * h * n + t * m);  
  
                // 将坐标转换为一维数组索引  
                int o = x + 80 * y;  
  
                // 计算字符的索引（基于深度和其他因素）  
                int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);  
  
                // 如果该点在屏幕上且深度大于之前记录的值，则更新它  
                if (22 > y && y > 0 && x > 0 && 80 > x && D > z[o]) {  
                    z[o] = D; // 更新深度值  
                    b[o] = ".,-~:;=!*#$@"[N > 0 ? N % 10 : 0]; // 更新字符（使用N的模10值作为索引）  
                }  
            }  
        }  
  
        // 将光标移动到左上角  
        printf("\x1b[H");  
  
        // 打印字符数组到终端  
        for (k = 0; k < 1760; k++) {  
            putchar(k % 80 ? b[k] : '\n'); // 如果不是每行的第一个字符，则打印字符；否则打印换行符  
            A += 0.00004; // 更新A的值  
            B += 0.00002; // 更新B的值（注意：这些更新实际上在每次循环迭代中都会发生多次，可能不是预期的行为）  
        }  
  
        // 暂停30毫秒  
        usleep(30000);  
    }  
  
    // 注意：由于这是一个无限循环，程序实际上不会到达这里  
    // 保留return语句是为了代码的完整性  
    return 0;  
}

windows版本

#include <stdio.h>  
#include <math.h>  
#include <string.h>  
#include <windows.h>  
  
void usleep(__int64 usec) {  
    HANDLE timer;  
    LARGE_INTEGER ft;  
  
    ft.QuadPart = -(10 * usec);  
  
    timer = CreateWaitableTimer(NULL, TRUE, NULL);  
    SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);  
    WaitForSingleObject(timer, INFINITE);  
    CloseHandle(timer);  
}  
  
int main() {  
    float A = 0, B = 0;  
    float i, j;  
    int k;  
    float z[1760];  
    char b[1760];  
  
    // 清屏  
    printf("\x1b[2J");  
  
    for (;;) {  
        memset(b, 32, sizeof(b));  
        memset(z, 0, sizeof(z));  
  
        for (j = 0; j < 6.28; j += 0.07) {  
            for (i = 0; i < 6.28; i += 0.02) {  
                float c = sin(i);  
                float d = cos(j);  
                float e = sin(A);  
                float f = sin(j);  
                float g = cos(A);  
                float h = d + 2;  
                float D = 1 / (c * h * e + f * g + 5);  
                float l = cos(i);  
                float m = cos(B);  
                float n = sin(B);  
                float t = c * h * g - f * e;  
                int x = 40 + 30 * D * (l * h * m - t * n);  
                int y = 12 + 15 * D * (l * h * n + t * m);  
                int o = x + 80 * y;  
                int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);  
  
                if (22 > y && y > 0 && x > 0 && 80 > x && D > z[o]) {  
                    z[o] = D;  
                    b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0];  
                }  
            }  
        }  
  
        // 移动光标到左上角  
        printf("\x1b[H");  
  
        for (k = 0; k < 1760; k++) {  
            putchar(k % 80 ? b[k] : '\n');  
            A += 0.00004;  
            B += 0.00002;  
        }  
  
        usleep(30000);  
    }  
  
    return 0;  
}

 

 

将C++代码转换为C语言版本主要涉及去除C++特有的特性和库，以及确保代码符合C语言的语法。以下是你提供的C++代码的C语言版本。主要修改包括：

  1. 移除C++标准库头文件 <cstring> 并使用C标准库 <string.h>。
  2. 使用C语言风格的字符串和数组操作。
  3. 确保所有变量声明在代码块的开始处（尽管C99允许在任意位置声明变量，但保持这种风格可以提高兼容性）。

#include <stdio.h>  
#include <math.h>  
#include <string.h>  
#include <windows.h>  
  
void usleep(__int64 usec) {  
    HANDLE timer;  
    LARGE_INTEGER ft;  
  
    ft.QuadPart = -(10 * usec);  
  
    timer = CreateWaitableTimer(NULL, TRUE, NULL);  
    SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);  
    WaitForSingleObject(timer, INFINITE);  
    CloseHandle(timer);  
}  
  
int main() {  
    float A = 0, B = 0;  
    float i, j;  
    int k;  
    float z[1760];  
    char b[1760];  
  
    // 清屏  
    printf("\x1b[2J");  
  
    for (;;) {  
        memset(b, 32, sizeof(b));  
        memset(z, 0, sizeof(z));  
  
        for (j = 0; j < 6.28; j += 0.07) {  
            for (i = 0; i < 6.28; i += 0.02) {  
                float c = sin(i);  
                float d = cos(j);  
                float e = sin(A);  
                float f = sin(j);  
                float g = cos(A);  
                float h = d + 2;  
                float D = 1 / (c * h * e + f * g + 5);  
                float l = cos(i);  
                float m = cos(B);  
                float n = sin(B);  
                float t = c * h * g - f * e;  
                int x = 40 + 30 * D * (l * h * m - t * n);  
                int y = 12 + 15 * D * (l * h * n + t * m);  
                int o = x + 80 * y;  
                int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);  
  
                if (22 > y && y > 0 && x > 0 && 80 > x && D > z[o]) {  
                    z[o] = D;  
                    b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0];  
                }  
            }  
        }  
  
        // 移动光标到左上角  
        printf("\x1b[H");  
  
        for (k = 0; k < 1760; k++) {  
            putchar(k % 80 ? b[k] : '\n');  
            A += 0.00004;  
            B += 0.00002;  
        }  
  
        usleep(30000);  
    }  
  
    return 0;  
}

c复制代码

#include <stdio.h> 
#include <math.h> 
#include <string.h> 
#include <windows.h> 
void usleep(__int64 usec) { 
HANDLE timer; 
LARGE_INTEGER ft; 
ft.QuadPart = -(10 * usec); 
timer = CreateWaitableTimer(NULL, TRUE, NULL); 
SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0); 
WaitForSingleObject(timer, INFINITE); 
CloseHandle(timer); 
} 
int main() { 
float A = 0, B = 0; 
float i, j; 
int k; 
float z[1760]; 
char b[1760]; 
// 清屏 
printf("\x1b[2J"); 
for (;;) { 
memset(b, 32, sizeof(b)); 
memset(z, 0, sizeof(z)); 
for (j = 0; j < 6.28; j += 0.07) { 
for (i = 0; i < 6.28; i += 0.02) { 
float c = sin(i); 
float d = cos(j); 
float e = sin(A); 
float f = sin(j); 
float g = cos(A); 
float h = d + 2; 
float D = 1 / (c * h * e + f * g + 5); 
float l = cos(i); 
float m = cos(B); 
float n = sin(B); 
float t = c * h * g - f * e; 
int x = 40 + 30 * D * (l * h * m - t * n); 
int y = 12 + 15 * D * (l * h * n + t * m); 
int o = x + 80 * y; 
int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n); 
if (22 > y && y > 0 && x > 0 && 80 > x && D > z[o]) { 
z[o] = D; 
b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0]; 
} 
} 
} 
// 移动光标到左上角 
printf("\x1b[H"); 
for (k = 0; k < 1760; k++) { 
putchar(k % 80 ? b[k] : '\n'); 
A += 0.00004; 
B += 0.00002; 
} 
usleep(30000); 
} 
return 0; 
}

说明

  1. 头文件：<cstring> 在C中对应 <string.h>。
  2. 变量声明：所有变量声明在代码块的开始处，尽管这在C99及更高版本中不是必需的，但有助于保持与C89的兼容性。
  3. 字符数组：在C中，字符数组和字符串操作与C++类似，但避免使用C++特有的特性，如 std::string。
  4. 打印：使用 putchar 和 printf 来输出字符和格式化字符串。

这样修改后的代码应该可以在C编译器中正确编译和运行。

 

为了将您的Windows C代码修改为在Linux上运行的C代码，我们需要做几个关键的更改。首先，usleep 函数在Linux中已经是标准库的一部分，所以我们不需要自己实现它。其次，清屏命令和光标移动命令在大多数Linux终端中也是有效的，但最好确认一下。最后，我们可能需要包含一些Linux特有的头文件，尽管在这个例子中并不需要。

以下是修改后的代码：



c复制代码

#include <stdio.h> 
#include <math.h> 
#include <string.h> 
#include <unistd.h> // 包含 usleep 函数 
// 在Linux中，usleep 函数的参数是微秒数，不需要自己实现 
void my_usleep(useconds_t usec) { 
usleep(usec); 
} 
int main() { 
float A = 0, B = 0; 
float i, j; 
int k; 
float z[1760]; 
char b[1760]; 
// 清屏，这个命令在大多数Linux终端中有效 
printf("\x1b[2J"); 
for (;;) { 
memset(b, 32, sizeof(b)); // 用空格填充字符数组 
memset(z, 0, sizeof(z)); // 将浮点数组清零 
for (j = 0; j < 6.28; j += 0.07) { 
for (i = 0; i < 6.28; i += 0.02) { 
float c = sin(i); 
float d = cos(j); 
float e = sin(A); 
float f = sin(j); 
float g = cos(A); 
float h = d + 2; 
float D = 1 / (c * h * e + f * g + 5); 
float l = cos(i); 
float m = cos(B); 
float n = sin(B); 
float t = c * h * g - f * e; 
int x = 40 + 30 * D * (l * h * m - t * n); 
int y = 12 + 15 * D * (l * h * n + t * m); 
int o = x + 80 * y; 
int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n); 
if (22 > y && y > 0 && x > 0 && 80 > x && D > z[o]) { 
z[o] = D; 
b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0]; 
} 
} 
} 
// 移动光标到左上角，这个命令在大多数Linux终端中有效 
printf("\x1b[H"); 
for (k = 0; k < 1760; k++) { 
putchar(k % 80 ? b[k] : '\n'); // 每80个字符打印一个换行符 
A += 0.00004; 
B += 0.00002; 
} 
// 调用Linux的usleep函数，参数是微秒数 
my_usleep(30000); // 或者直接使用 usleep(30000); 
} 
return 0; 
}

然而，在这个特定的例子中，my_usleep 函数实际上是多余的，因为我们可以直接调用 usleep。所以，你可以进一步简化代码，去掉 my_usleep 函数，直接在循环中使用 usleep(30000);。

另外，请注意，这个程序在Linux终端上运行时，可能会因为无限循环和大量的输出而导致终端变得非常慢或无法响应。你可能需要一种方法来优雅地中断程序，比如通过检测特定的键盘输入。但是，这超出了当前问题的范围。

 

这个错误信息表明，在编译 donut.c 文件时，链接器（ld）无法找到 sin 和 cos 函数的定义。这两个函数是数学库（通常是 libm）的一部分，在 C 语言中用于计算正弦和余弦值。

要解决这个问题，你需要在编译时链接数学库。在 GCC 中，这可以通过添加 -lm 选项来实现。-lm 选项告诉链接器链接数学库。

所以，你应该使用以下命令来编译你的程序：



bash复制代码

gcc donut.c -lm -o donut

这里，-o donut 选项指定了输出文件的名称（在这个例子中是 donut）。如果你省略了这个选项，GCC 会默认生成一个名为 a.out 的可执行文件。

确保你的系统上安装了数学库。在大多数基于 Linux 的系统上，这个库是默认安装的。但是，如果你在一个非常精简的系统或者嵌入式系统上工作，可能需要手动安装它。

另外，请注意，你的代码中有一些可能的问题点，比如 A 和 B 的更新位置。在当前的代码中，A 和 B 在打印循环内部被更新，这意味着它们的值会在每次打印字符时都发生变化。这可能会导致动画效果不如预期。通常，你会希望在一个循环迭代中只更新一次 A 和 B 的值，然后在整个屏幕绘制完成后再进行下一次更新。你可以通过将 A += 0.00004; 和 B += 0.00002; 这两行代码移到打印循环之外来实现这一点。

总结如下：

用户提供了一个C语言程序（donut.c），该程序旨在生成一个动态变化的图案（可能类似于一个“甜甜圈”或波浪效果），并在终端上显示出来。然而，在尝试使用GCC编译该程序时，遇到了链接错误，提示sin和cos函数未定义。

这些函数是数学库（libm）的一部分，用于计算正弦和余弦值。在C语言中，当使用数学库中的函数时，需要在编译时链接该库。这可以通过在GCC命令中添加-lm选项来实现。

此外，还指出了代码中的几个潜在问题：

  1. 性能问题：程序包含大量的数学计算和数组访问，可能在较慢的计算机或终端上运行缓慢。
  2. 无限循环：程序包含一个无限循环，这意味着它将永远运行，除非被外部中断（如关闭终端窗口或使用Ctrl+C）。
  3. 变量更新位置：在打印循环中更新A和B的值可能不是预期的行为，因为这会导致它们在每次打印字符时都发生变化。建议将它们的更新移到打印循环之外。
  4. 字符数组索引：虽然在当前代码中，由于x和y的限制条件，o的值应该始终在b数组的有效范围内，但在修改或扩展代码时，需要确保不会发生数组越界。
  5. 字符选择：使用N % 10作为索引来选择字符可能不是最佳选择，因为它可能会丢失N中的大部分信息。根据需求，可能需要调整这部分逻辑。

最终，用户被告知应使用以下命令来编译程序：



bash复制代码

gcc donut.c -lm -o donut

这将生成一个名为donut的可执行文件，其中包含了链接数学库所需的必要信息。用户还被提醒确保他们的系统上安装了数学库，并考虑调整代码中的变量更新位置和字符选择逻辑。

举报

相关推荐

Blender学习记录（甜甜圈）

blender

C# WPF 绘制 3D 甜甜圈

数据库neo4j

荞面打造的甜蜜魔法：甜甜圈

网络SecureCRT终端 SSH 工具

饼图也疯狂--论饼图的各种变体（甜甜圈，扇形，轨道，圈等）

数据可视化数据分析

甜甜圈行业调研报告 - 市场现状分析与发展前景预测

p2pbig data网络协议其他

iOS 17（SwiftUI 5.0）带来的图表（Charts）新类型：“大饼”与“甜甜圈”

学习python开发语言

Aixcoder：AI辅助编程工具

机器学习聚类算法pythonk-means

AI辅助编程工具—Github Copilot

分布式微服务serverless

C语言通讯录-动态版

C语言动态内存通讯录C/C++后端开发

AI 辅助编程的效果如何衡量？

开发者编码效率开发效率云服务云计算
0 条评论