• 云课五分钟-05一段代码修改-AI修改C++

    前篇：

    云课五分钟-04一段代码学习-大模型分析C++

    在前一节，使用大模型工具文心一言等可以帮助分析代码，加快理解。

    信息时代→智能时代，系统学习转为碎片学习。

    发散思维的能力在智能时代尤为重要。 

    同样我们也可以借助智能化工具修改代码，提出自己的需求。

    所有的云课五分钟，不仅演示可行案例，也同样重视在尝试过程中的失败，并且也会全部展示出来。

    一次又一次在失败中站起来，这也许就是人区别于机器人所具有的独特成长历程，弥足珍贵。

    视频与文字并非对应关系，类似互补关系，同时又相互独立。

    视频：

    云课五分钟-05一段代码修改-AI修改C++

    文字：

    usleep(30000); 实现什么功能

    usleep(30000); 实现的功能是使程序暂停30000微秒（也就是0.03秒或30毫秒）。

    在这段代码中，usleep函数用于在每次循环迭代之间添加一个小的延迟。这样做有几个目的：

    1. 可视化效果：使得用户能够观察到图形的动态变化。如果没有这个延迟，图形变化会过快，可能难以观察。
    2. 减轻CPU负担：减少程序的运行频率，从而降低CPU的使用率。这对于轻量级和不需要高频率更新的应用是有益的。
    3. 节奏控制：对于动态系统或者动画来说，usleep可以用于控制系统的更新速度或者动画的帧率。

    简单来说，usleep(30000);就是用来在每次循环迭代中创建一个小的延迟，以提供更好的用户体验并降低CPU的使用率。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. int main() {
    7.     float A = 0, B = 0;
    8.     float i, j;
    9.     int k;
    10.     float z[1760];
    11.     char b[1760];
    12.     printf("\x1b[2J");
    13.     for (;;) {
    14.         memset(b, 32, 1760);
    15.         memset(z, 0, 7040);
    16.         for (j = 0; j < 6.28; j += 0.07) {
    17.             for (i = 0; i < 6.28; i += 0.02) {
    18.                 float c = sin(i);
    19.                 float d = cos(j);
    20.                 float e = sin(A);
    21.                 float f = sin(j);
    22.                 float g = cos(A);
    23.                 float h = d + 2;
    24.                 float D = 1 / (c * h * e + f * g + 5);
    25.                 float l = cos(i);
    26.                 float m = cos(B);
    27.                 float n = sin(B);
    28.                 float t = c * h * g - f * e;
    29.                 int x = 40 + 30 * D * (l * h * m - t * n);
    30.                 int y = 12 + 15 * D * (l * h * n + t * m);
    31.                 int o = x + 80 * y;
    32.                 int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);
    33.                 if (22 > y && y > 0 && x > 0 && 80 > x && D > z[o]) {
    34.                     z[o] = D;
    35.                     b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0];
    36.                 }
    37.             }
    38.         }
    39.         printf("\x1b[H");
    40.         for (k = 0; k < 1761; k++) {
    41.             putchar(k % 80 ? b[k] : 10);
    42.             A += 0.00004;
    43.             B += 0.00002;
    44.         }
    45.         usleep(30000);
    46.     }
    47.     return 0;
    48. }

    修改如上代码，使得动态效果变慢一倍。

    如果你想让动态效果变慢一倍，你可以简单地将 usleep(30000); 这行代码修改为 usleep(60000);。这将使得程序在每次循环迭代后暂停60000微秒（也就是0.06秒或60毫秒），是原来的两倍时间。

    所以修改后的代码如下：

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5.    
    6. int main() {  
    7.     float A = 0, B = 0;  
    8.     float i, j;  
    9.     int k;  
    10.     float z[1760];  
    11.     char b[1760];  
    12.     printf("\x1b[2J");  
    13.     for (;;) {  
    14.         memset(b, 32, 1760);  
    15.         memset(z, 0, 7040);  
    16.         for (j = 0; j < 6.28; j += 0.07) {  
    17.             for (i = 0; i < 6.28; i += 0.02) {  
    18.                 // ... (unchanged code)  
    19.             }  
    20.         }  
    21.         printf("\x1b[H");  
    22.         for (k = 0; k < 1761; k++) {  
    23.             putchar(k % 80 ? b[k] : 10);  
    24.             A += 0.00004;  
    25.             B += 0.00002;  
    26.         }  
    27.         usleep(60000);  // Changed from usleep(30000)  
    28.     }  
    29.     return 0;  
    30. }

    这样做将使得动态图形的更新速度变慢，使得其变化更加易于观察。

    对于简单的修改要求，AI基本都能完成。

    但是，要求多了，需要细节描述好，同时，也有概率出现无法解决的情况。 

    能否修改如上代码，显示彩色的动态效果。

    在终端中显示彩色文本通常需要用到ANSI转义码。你可以通过修改b[o]的赋值部分来实现彩色效果。

    首先，你需要定义一个颜色数组，这个数组包含你想要用的ANSI颜色码。然后，你可以像之前一样使用".,-~:;=!*#$@"数组来选择颜色。

    以下是一个简单的修改版本，这里我仅展示了如何将b[o]修改为彩色，我使用了10种不同的颜色来循环：

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5.   
    6. // ANSI color codes for the colors  
    7. const char* colors[] = {  
    8.     "\x1b[31m", // Red  
    9.     "\x1b[32m", // Green  
    10.     "\x1b[33m", // Yellow  
    11.     "\x1b[34m", // Blue  
    12.     "\x1b[35m", // Magenta  
    13.     "\x1b[36m", // Cyan  
    14.     "\x1b[31;1m", // Bold Red  
    15.     "\x1b[32;1m", // Bold Green  
    16.     "\x1b[33;1m", // Bold Yellow  
    17.     "\x1b[37m"  // White  
    18. };  
    19.   
    20. int main() {  
    21.     float A = 0, B = 0;  
    22.     float i, j;  
    23.     int k;  
    24.     float z[1760];  
    25.     char b[1760];  
    26.     printf("\x1b[2J");  
    27.     for (;;) {  
    28.         memset(b, 32, 1760);  
    29.         memset(z, 0, 7040);  
    30.         for (j = 0; j < 6.28; j += 0.07) {  
    31.             for (i = 0; i < 6.28; i += 0.02) {  
    32.                 // ... (unchanged code)  
    33.                 int color_index = N > 0 ? N % 10 : 0;  // Cycle colors if there are more points than colors  
    34.                 b[o] = colors[color_index];  // Set the color for this point  
    35.                 // You might want to append the actual character here like: b[o] = colors[color_index] + ".";  
    36.                 // It depends on what visual effect you're aiming for.  
    37.             }  
    38.         }  
    39.         printf("\x1b[H");  
    40.         for (k = 0; k < 1761; k++) {  
    41.             putchar(k % 80 ? b[k] : 10);  
    42.             A += 0.00004;  
    43.             B += 0.00002;  
    44.         }  
    45.         usleep(60000);  
    46.     }  
    47.     return 0;  
    48. }

    注意: 上述代码片段假定N的值是变化的，并且可以提供足够的颜色变化。如果N的变化不足以提供所有颜色的变化，你可能需要找到另一种方式来映射点到颜色。同时，要记住在最后的putchar之后重置颜色，可以使用\x1b[0m来重置到默认颜色。如果字符和颜色是分开的（即使用了注释中的append方法），你可能需要在字符后面添加这个重置码。 

    在编译如上代码时，出现报错，错误如下：code03.cpp: In function ‘int main()’: code03.cpp:52:42: error: invalid conversion from ‘const char*’ to ‘char’ [-fpermissive] b[o] = colors[color_index]; // Set the color for this point ^ code03.cpp:66:1: error: expected ‘}’ at end of input }

    这里有两个问题：

    1. 类型不匹配：b[o]被定义为char，但你试图将const char*（字符串）赋给它，这就是第一个错误的原因
    2. 缺少结束大括号：你的代码结构可能没有正确地关闭，这会导致第二个错误

    解决方案

    1. 对于类型不匹配问题：

    如果你想存储ANSI颜色代码，你应该将b数组的类型从char改为const char*，这样可以存储字符串而不是单个字符但是，这样做的话你需要确保其他部分的代码与这个类型兼容

    代码修改如下：

    cpp

    const char* b[1760];
    // ...
    b[o] = colors[color_index];
    1. 对于缺少结束大括号问题：

    确保所有的代码块都有正确的结束大括号}你需要在报错的位置检查前面的代码块，确保每个开始的{都有对应的结束}

    根据提供的代码片段，这两个修改应该能够解决你的问题但是，如果这些修改后仍然存在问题，请提供更多的代码上下文，以便我能更全面地理解和解决问题

    这段代码看起来像是一个基于终端的动画，使用 ASCII 字符来显示一种动态模式。它已经在做一些相当复杂的数学计算来生成这个动画。这段代码使用了正弦和余弦函数来生成形状，并使用了循环来持续更新画面。

    你可以尝试以下几种方式来让这段代码变得更有趣：

    1. 交互性：目前，这个动画是预设的，且无法与用户交互。你可以考虑通过读取键盘输入来改变动画的某些参数，使之能够与用户交互。例如，可以让用户通过按键来改变颜色、形状、动画速度等。
    2. 颜色：目前这个动画只使用了 ASCII 字符，你可以考虑引入颜色来增加视觉效果。需要注意的是，终端中输出颜色需要特殊的控制序列，你可以查找 ANSI escape code 来了解如何在终端中输出颜色。
    3. 音效：虽然这是一个视觉动画，但如果你增加一些音效可能会更有趣。例如，当特定的形状或模式出现时，可以播放特定的声音。需要注意的是，这可能需要引入一些音频库来实现。
    4. 更复杂的模式：你可以尝试引入更复杂的数学函数来生成更复杂的模式。例如，你可以尝试使用分形或者其他复杂的数学函数。
    5. 保存/分享动画：允许用户保存或分享他们创建的动画。这可能需要将动画转换为视频或者 GIF 格式。

    在修改和增加功能的过程中，需要注意的是保持代码的清晰和可读性。同时，因为这段代码涉及到大量的数学运算，所以在增加功能的同时也要考虑性能的影响。

     

    当然！以下是一个修改后的示例，增加了颜色和交互性。请注意，这个示例需要终端支持ANSI escape codes来显示颜色。 

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5.   
    6. // 定义ANSI escape codes  
    7. #define COLOR_RESET "\033[0m"  
    8. #define COLOR_RED "\033[31m"  
    9. #define COLOR_GREEN "\033[32m"  
    10. #define COLOR_YELLOW "\033[33m"  
    11. #define COLOR_BLUE "\033[34m"  
    12.   
    13. int main() {  
    14.     float A = 0, B = 0;  
    15.     float i, j;  
    16.     int k;  
    17.     float z[1760];  
    18.     char b[1760];  
    19.   
    20.     printf("\x1b[2J"); // 清屏  
    21.   
    22.     bool running = true;  
    23.     int colorIndex = 0;  
    24.   
    25.     while (running) {  
    26.         memset(b, 32, 1760);  
    27.         memset(z, 0, 7040);  
    28.   
    29.         for (j = 0; j < 6.28; j += 0.07) {  
    30.             for (i = 0; i < 6.28; i += 0.02) {  
    31.                 // ... (保持不变的部分)  
    32.                 float c = cos(i);
    33.                 float d = sin(j);
    34.                 float e = cos(A);
    35.                 float f = cos(j);
    36.                 float g = sin(A);
    37.                 float h = d + 2;
    38.                 float D = 1 / (c * h * e + f * g + 5);
    39.                 float l = sin(i);
    40.                 float m = sin(B);
    41.                 float n = cos(B);
    42.                 float t = c * h * g - f * e;
    43.                 int x = 40 + 30 * D * (l * h * m - t * n);
    44.                 int y = 12 + 15 * D * (l * h * n + t * m);
    45.                 int o = x + 80 * y;
    46.                 int N = 8 * ((f * e - c * d * g) * m - c * d * e - f * g - l * d * n);  
    47.                 // 在这里增加颜色  
    48.                 const char* colorCode;  
    49.                 switch (colorIndex) {  
    50.                     case 0:  
    51.                         colorCode = COLOR_RED;  
    52.                         break;  
    53.                     case 1:  
    54.                         colorCode = COLOR_GREEN;  
    55.                         break;  
    56.                     case 2:  
    57.                         colorCode = COLOR_YELLOW;  
    58.                         break;  
    59.                     case 3:  
    60.                         colorCode = COLOR_BLUE;  
    61.                         break;  
    62.                     default:  
    63.                         colorCode = COLOR_RESET;  
    64.                         break;  
    65.                 }  
    66.   
    67.                 if (22 > y && y > 0 && x > 0 && 80 > x && D > z[o]) {  
    68.                     z[o] = D;  
    69.                     b[o] = colorCode[0]; // 使用颜色代码作为字符的前缀  
    70.                     b[o + 1] = ".,-~:;=!*#$@"[N > 0 ? N : 0];  
    71.                 }  
    72.             }  
    73.         }  
    74.   
    75.         printf("\x1b[H"); // 移动光标到屏幕左上角  
    76.   
    77.         for (k = 0; k < 1761; k++) {  
    78.             putchar(k % 80 ? b[k] : 10); // 输出字符或换行  
    79.             A += 0.00004;  
    80.             B += 0.00002;  
    81.         }  
    82.   
    83.         // 增加交互性：根据用户输入改变颜色  
    84.         char input;  
    85.         if (scanf(" %c", &input) == 1) {  
    86.             if (input == 'r') { // 'r' 键重置颜色索引  
    87.                 colorIndex = 0;  
    88.             } else if (input >= '1' && input <= '4') { // 数字键1-4更改颜色索引  
    89.                 colorIndex = input - '1';  
    90.             } else if (input == 'q') { // 'q' 键退出程序  
    91.                 running = false;  
    92.             }  
    93.         }  
    94.   
    95.         usleep(30000); // 暂停一段时间，控制动画速度  
    96.     }  
    97.     return 0;
    98.  }

    这个警告是因为你试图将一个字符串常量（这里是COLOR_RED）赋值给一个非const的char*（这里是colorCode）。在C++中，字符串常量被视为const char类型，因此它们不能被赋值给一个非const的char*。

    为了解决这个问题，你应该将colorCode声明为const char*。如果你的代码里的其它地方需要修改colorCode指向的内容，那你就需要重新考虑你的设计。一般来说，字符串常量（比如这里的颜色代码）应该是只读的。

    所以你应该修改你的代码，使得colorCode被声明为const char*。例如：

    1. const char* colorCode;  
    2. switch (colorIndex) {  
    3.     case 0:  
    4.         colorCode = COLOR_RED;  
    5.         break;  
    6.     case 1:  
    7.         colorCode = COLOR_GREEN;  
    8.         break;  
    9.     case 2:  
    10.         colorCode = COLOR_YELLOW;  
    11.         break;  
    12.     case 3:  
    13.         colorCode = COLOR_BLUE;  
    14.         break;  
    15.     default:  
    16.         colorCode = COLOR_RESET;  
    17.         break;  
    18. }

    cpp

    const char* colorCode;
    switch (colorIndex) {
    case 0:
    colorCode = COLOR_RED;
    break;
    case 1:
    colorCode = COLOR_GREEN;
    break;
    case 2:
    colorCode = COLOR_YELLOW;
    break;
    case 3:
    colorCode = COLOR_BLUE;
    break;
    default:
    colorCode = COLOR_RESET;
    break;
    }

    然后，在你的代码中使用colorCode时，如果之前的代码试图修改它指向的字符串内容（比如通过strcpy或者[]操作符），那么你需要修复那些代码，使其不再试图修改字符串常量。如果这些代码需要修改字符串，那么他们应该使用堆或者栈上分配的（非const）字符串，而不是字符串常量。

     

  • 相关阅读:
    重磅 | 死磕 Elasticsearch 8.X 方法论认知清单（2022年国庆更新版）
    人工智能轨道交通行业周刊-第7期（2022.7.25-7.31）
    what‘s the meaning of rv32imafdc
    10贪心：柠檬水找零
    Eureka如何处理网络分区和服务雪崩问题？
    GoFrame+Vue+ElementUI框架快速入门教程
    面试：常用的设计模式总结
    PHP之mysql面试题大全(持续更新中)
    【二】编码器原理与电机转速、角度控制
    第3周学习：ResNet+ResNeXt
  • 原文地址：https://blog.csdn.net/ZhangRelay/article/details/134435369