main int a=10, y-0; do { at=2; y+=a; if(y>50) break; } while (a=14); printf(**In %d,%d",a,y);

这段代码中有几个问题需要修正：

1. 第二行应该是 `int y=0;` 而不是 `y-0;`
2. 第三行的 `at=2;` 应该改为 `a=2;`
3. 第五行的 `a=14` 应该改为 `a+=2;`，否则循环条件永远为真，会导致死循环。

修正后的代码如下：

int a = 10, y = 0;
do {
    a = 2;
    y += a;
    if (y > 50) {
        break;
    }
    a += 2;
} while (a <= 14);
printf("In %d,%d", a, y);

输出结果为：`In 16,54`。

相关问题

AT32F413芯片用ST7789驱动1.3寸分辨率240×240代码

以下是使用AT32F413芯片控制ST7789驱动1.3寸240x240分辨率显示屏的代码示例：

#include "at32f4xx.h"
#include "at32_board.h"
#include "stdio.h"

#define TFT_CS_Pin GPIO_Pin_4
#define TFT_CS_Port GPIOA
#define TFT_RST_Pin GPIO_Pin_5
#define TFT_RST_Port GPIOA
#define TFT_DC_Pin GPIO_Pin_6
#define TFT_DC_Port GPIOA

#define TFT_WIDTH 240
#define TFT_HEIGHT 240

#define TFT_CMD  0
#define TFT_DATA 1

void delay_us(uint32_t us)
{
    uint32_t i,j;
    for(i=0;i<us;i++)
        for(j=0;j<15;j++);
}

void spi_write(uint8_t data)
{
    while(SPI_GetFlagStatus(SPI1, SPI_FLAG_TXBE) == RESET);
    SPI_SendData(SPI1, data);
    while(SPI_GetFlagStatus(SPI1, SPI_FLAG_RXBNE) == RESET);
    SPI_ReceiveData(SPI1);
}

void tft_write_cmd(uint8_t cmd)
{
    GPIO_ResetBits(TFT_DC_Port, TFT_DC_Pin);
    spi_write(cmd);
}

void tft_write_data(uint8_t data)
{
    GPIO_SetBits(TFT_DC_Port, TFT_DC_Pin);
    spi_write(data);
}

void tft_init()
{
    GPIO_ResetBits(TFT_RST_Port, TFT_RST_Pin);
    delay_us(50000);
    GPIO_SetBits(TFT_RST_Port, TFT_RST_Pin);
    delay_us(50000);

    tft_write_cmd(0x11); // sleep out
    delay_us(120000);

    tft_write_cmd(0xB1);
    tft_write_data(0x01);
    tft_write_data(0x2C);
    tft_write_data(0x2D);

    tft_write_cmd(0xB2);
    tft_write_data(0x01);
    tft_write_data(0x2C);
    tft_write_data(0x2D);

    tft_write_cmd(0xB3);
    tft_write_data(0x01);
    tft_write_data(0x2C);
    tft_write_data(0x2D);
    tft_write_data(0x01);
    tft_write_data(0x2C);
    tft_write_data(0x2D);

    tft_write_cmd(0xB4); // column inversion
    tft_write_data(0x07);

    tft_write_cmd(0xC0); // power control
    tft_write_data(0xA2);
    tft_write_data(0x02);
    tft_write_data(0x84);

    tft_write_cmd(0xC1); // power control
    tft_write_data(0xC5);

    tft_write_cmd(0xC2); // power control
    tft_write_data(0x0A);
    tft_write_data(0x00);

    tft_write_cmd(0xC3); // power control
    tft_write_data(0x8A);
    tft_write_data(0x2A);
    tft_write_cmd(0xC4);
    tft_write_data(0x8A);
    tft_write_data(0xEE);

    tft_write_cmd(0xC5); // vcom control
    tft_write_data(0x0E);

    tft_write_cmd(0x36); // memory access
    tft_write_data(0xC8);

    tft_write_cmd(0x3A);
    tft_write_data(0x05);

    tft_write_cmd(0x20); // display inversion off

    tft_write_cmd(0x13); // normal display mode

    tft_write_cmd(0x29); // display on
}

void tft_set_addr_window(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1)
{
    tft_write_cmd(0x2A);
    tft_write_data(x0 >> 8);
    tft_write_data(x0 & 0xFF);
    tft_write_data(x1 >> 8);
    tft_write_data(x1 & 0xFF);

    tft_write_cmd(0x2B);
    tft_write_data(y0 >> 8);
    tft_write_data(y0 & 0xFF);
    tft_write_data(y1 >> 8);
    tft_write_data(y1 & 0xFF);

    tft_write_cmd(0x2C);
}

void tft_fill_screen(uint16_t color)
{
    uint16_t x, y;

    tft_set_addr_window(0, 0, TFT_WIDTH - 1, TFT_HEIGHT - 1);

    for (y = 0; y < TFT_HEIGHT; ++y) {
        for (x = 0; x < TFT_WIDTH; ++x) {
            tft_write_data(color >> 8);
            tft_write_data(color & 0xFF);
        }
    }
}

void tft_draw_pixel(uint16_t x, uint16_t y, uint16_t color)
{
    tft_set_addr_window(x, y, x, y);
    tft_write_data(color >> 8);
    tft_write_data(color & 0xFF);
}

void tft_draw_line(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint16_t color)
{
    int32_t dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
    int32_t dy = abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
    int32_t err = (dx > dy ? dx : -dy) / 2;

    while (1) {
        tft_draw_pixel(x0, y0, color);
        if (x0 == x1 && y0 == y1) break;
        int32_t e2 = err;
        if (e2 > -dx) { err -= dy; x0 += sx; }
        if (e2 < dy) { err += dx; y0 += sy; }
    }
}

void tft_draw_rect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color)
{
    tft_draw_line(x, y, x + w - 1, y, color);
    tft_draw_line(x, y, x, y + h - 1, color);
    tft_draw_line(x + w - 1, y, x + w - 1, y + h - 1, color);
    tft_draw_line(x, y + h - 1, x + w - 1, y + h - 1, color);
}

void tft_fill_rect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color)
{
    uint16_t i, j;
    tft_set_addr_window(x, y, x + w - 1, y + h - 1);
    for (i = 0; i < w; ++i) {
        for (j = 0; j < h; ++j) {
            tft_write_data(color >> 8);
            tft_write_data(color & 0xFF);
        }
    }
}

void tft_draw_circle(int16_t x0, int16_t y0, int16_t r, uint16_t color)
{
    int16_t x = -r, y = 0, err = 2 - 2 * r;
    do {
        tft_draw_pixel(x0 - x, y0 + y, color);
        tft_draw_pixel(x0 - y, y0 - x, color);
        tft_draw_pixel(x0 + x, y0 - y, color);
        tft_draw_pixel(x0 + y, y0 + x, color);

        r = err;
        if (r > x) err += ++x * 2 + 1;
        if (r <= y) err += ++y * 2 + 1;
    } while (x < 0);
}

void tft_fill_circle(int16_t x0, int16_t y0, int16_t r, uint16_t color)
{
    int16_t x = -r, y = 0, err = 2 - 2 * r;
    do {
        tft_draw_line(x0 - x, y0 - y, x0 - x, y0 + y, color);
        tft_draw_line(x0 - y, y0 - x, x0 - y, y0 + x, color);
        tft_draw_line(x0 + x, y0 - y, x0 + x, y0 + y, color);
        tft_draw_line(x0 + y, y0 - x, x0 + y, y0 + x, color);

        r = err;
        if (r > x) err += ++x * 2 + 1;
        if (r <= y) err += ++y * 2 + 1;
    } while (x < 0);
}

int main(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure;
    SPI_InitTypeDef SPI_InitStructure;

    GPIO_InitStructure.GPIO_Pin = TFT_CS_Pin | TFT_DC_Pin;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = TFT_RST_Pin;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_SetBits(TFT_CS_Port, TFT_CS_Pin);
    GPIO_ResetBits(TFT_DC_Port, TFT_DC_Pin);

    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_Init(SPI1, &SPI_InitStructure);

    SPI_Cmd(SPI1, ENABLE);

    tft_init();
    tft_fill_screen(0x0000); // 填充黑色
    tft_draw_circle(120, 120, 60, 0xF800); // 画圆
    tft_draw_rect(20, 20, 200, 200, 0x07E0); // 画矩形
    tft_fill_rect(60, 60, 120, 120, 0x001F); // 填充矩形
    while (1);

    return 0;
}

这个代码使用了AT32F413芯片的SPI1模块来控制ST7789驱动的显示屏，并提供了一些简单的图形绘制函数。需要注意的是，不同的驱动芯片和显示屏规格可能需要不同的初始化代码和操作方式，具体请参考相关的技术文档和示例代码。

本次实验的任务为采用模板技术设计动态数组类 DynamicArray，要求系统设计具有一定弹性和可扩展性，使得后续维护和扩展功能更容易，增加或修改系统功能变得更简单。基本要求和功能如下： （1）数组元素可动态实例化为int、double、string、Point等。 （2）类模板成员包括：数组长度、元素个数、数据指针。 （3）通过构造函数创建数组，默认包含10个元素，通过析构函数释放数组数据。 （4）追加数组元素：void AddItems(T aData[], int aLen); 在数组末尾添加aLen个元素，注意如果数组长度不够，需要动态扩展。 （5）删除数据元素：bool RemoveAt(int index); 返回是否删除成功。 （6）插入数组元素 void InsertItem( int index, T aData); 在数组的第index的位置插入元素aData，注意如果数组长度不够，需要动态扩展。 （7）数组元素排序，void mySort();根据以上要求写出一个程序，除此之外还需要写出对应的主函数，写出main函数，要求main函数中包括菜单，菜单内容包括数组元素可动态实例化为int、double、string、Point，和各个功能，功能包括输入数据，追加数据，删除数据，插入数据，数组元素排序。 对应各个功能

的菜单选项为：

1. 选择数据类型
2. 输入数据
3. 追加数据
4. 删除数据
5. 插入数据
6. 排序数据
7. 退出程序

以下是一个可能的实现方式，供参考：

#include <iostream>
#include <string>
#include <algorithm> // for std::sort
using namespace std;

template <typename T>
class DynamicArray {
private:
    T* mData; // 指向数组的指针
    int mSize; // 数组长度
    int mCount; // 元素个数
public:
    // 构造函数
    DynamicArray(int size = 10) : mSize(size), mCount(0) {
        mData = new T[size];
    }
    // 析构函数
    ~DynamicArray() {
        delete[] mData;
    }
    // 添加元素
    void AddItems(T aData[], int aLen) {
        if (mCount + aLen > mSize) {
            // 需要扩展数组
            T* newData = new T[mSize * 2];
            for (int i = 0; i < mCount; i++) {
                newData[i] = mData[i];
            }
            delete[] mData;
            mData = newData;
            mSize *= 2;
        }
        for (int i = 0; i < aLen; i++) {
            mData[mCount++] = aData[i];
        }
    }
    // 删除元素
    bool RemoveAt(int index) {
        if (index < 0 || index >= mCount) {
            return false;
        }
        for (int i = index; i < mCount - 1; i++) {
            mData[i] = mData[i + 1];
        }
        mCount--;
        return true;
    }
    // 插入元素
    void InsertItem(int index, T aData) {
        if (index < 0 || index > mCount) {
            return;
        }
        if (mCount + 1 > mSize) {
            // 需要扩展数组
            T* newData = new T[mSize * 2];
            for (int i = 0; i < mCount; i++) {
                newData[i] = mData[i];
            }
            delete[] mData;
            mData = newData;
            mSize *= 2;
        }
        for (int i = mCount; i > index; i--) {
            mData[i] = mData[i - 1];
        }
        mData[index] = aData;
        mCount++;
    }
    // 排序元素
    void mySort() {
        std::sort(mData, mData + mCount);
    }
    // 获取元素个数
    int GetCount() const {
        return mCount;
    }
    // 获取元素
    T& operator[](int index) {
        return mData[index];
    }
};

// Point 类
class Point {
private:
    int mX;
    int mY;
public:
    Point(int x = 0, int y = 0) : mX(x), mY(y) {}
    bool operator<(const Point& other) const {
        return mX < other.mX || (mX == other.mX && mY < other.mY);
    }
    friend ostream& operator<<(ostream& os, const Point& p) {
        os << "(" << p.mX << ", " << p.mY << ")";
        return os;
    }
};

// 输入数据
template <typename T>
void InputData(DynamicArray<T>& arr) {
    int n;
    cout << "请输入元素个数：";
    cin >> n;
    T* data = new T[n];
    for (int i = 0; i < n; i++) {
        cout << "请输入第 " << i + 1 << " 个元素：";
        cin >> data[i];
    }
    arr.AddItems(data, n);
    delete[] data;
    cout << "输入成功！" << endl;
}

// 追加数据
template <typename T>
void AppendData(DynamicArray<T>& arr) {
    int n;
    cout << "请输入要追加的元素个数：";
    cin >> n;
    T* data = new T[n];
    for (int i = 0; i < n; i++) {
        cout << "请输入要追加的第 " << i + 1 << " 个元素：";
        cin >> data[i];
    }
    arr.AddItems(data, n);
    delete[] data;
    cout << "追加成功！" << endl;
}

// 删除数据
template <typename T>
void RemoveData(DynamicArray<T>& arr) {
    int index;
    cout << "请输入要删除的元素下标：";
    cin >> index;
    if (arr.RemoveAt(index)) {
        cout << "删除成功！" << endl;
    } else {
        cout << "删除失败！下标越界。" << endl;
    }
}

// 插入数据
template <typename T>
void InsertData(DynamicArray<T>& arr) {
    int index;
    T data;
    cout << "请输入要插入的元素下标：";
    cin >> index;
    cout << "请输入要插入的元素：";
    cin >> data;
    arr.InsertItem(index, data);
    cout << "插入成功！" << endl;
}

// 排序数据
template <typename T>
void SortData(DynamicArray<T>& arr) {
    arr.mySort();
    cout << "排序成功！" << endl;
}

// 主函数
int main() {
    int choice;
    cout << "请选择数据类型：" << endl;
    cout << "1. int" << endl;
    cout << "2. double" << endl;
    cout << "3. string" << endl;
    cout << "4. Point" << endl;
    DynamicArray<int> intArr;
    DynamicArray<double> doubleArr;
    DynamicArray<string> stringArr;
    DynamicArray<Point> pointArr;
    do {
        cout << "请选择功能：" << endl;
        cout << "1. 输入数据" << endl;
        cout << "2. 追加数据" << endl;
        cout << "3. 删除数据" << endl;
        cout << "4. 插入数据" << endl;
        cout << "5. 排序数据" << endl;
        cout << "6. 退出程序" << endl;
        cin >> choice;
        switch (choice) {
            case 1:
                cout << "输入数据类型为 int，请输入数据：" << endl;
                InputData(intArr);
                break;
            case 2:
                cout << "追加数据类型为 int，请输入数据：" << endl;
                AppendData(intArr);
                break;
            case 3:
                cout << "删除数据类型为 int，请输入数据：" << endl;
                RemoveData(intArr);
                break;
            case 4:
                cout << "插入数据类型为 int，请输入数据：" << endl;
                InsertData(intArr);
                break;
            case 5:
                cout << "排序数据类型为 int，请输入数据：" << endl;
                SortData(intArr);
                break;
            case 6:
                cout << "程序已退出。" << endl;
                break;
            default:
                cout << "无效选项，请重新输入。" << endl;
        }
    } while (choice != 6);

    return 0;
}