c语言中用到static写一个输出一行n个*的程序

当输入为0时，这个程序应该不会输出任何内容，是吧？

下面是这个程序的实现：

#include <stdio.h>

void print_n_stars(int n);

int main() {
    int n;
    printf("请输入n的值：");
    scanf("%d", &n);
    print_n_stars(n);
    return 0;
}

void print_n_stars(int n) {
    static int count = 0;
    if (count == n) {
        printf("\n");  // 输出换行符
        count = 0;     // 计数器清零
        return;
    }
    printf("*");
    count++;
    print_n_stars(n);
}

相关问题

你能用c语言在codeblocks中用opengl 的glut库绘制一个四阶魔方吗，三百行代码以上

当然可以，以下是一个在 Code::Blocks 中使用 OpenGL 的 GLUT 库绘制四阶魔方的示例代码。由于代码比较长，我会把代码分开来逐一解释。

#include <stdio.h>
#include <stdlib.h>
#include <GL/glut.h>

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT 600

#define CUBE_SIZE 1.0f
#define CUBE_GAP 0.1f
#define CUBE_TOTAL_SIZE (CUBE_SIZE + CUBE_GAP)

#define ROTATE_STEP 3.0f

#define KEY_UP 101
#define KEY_DOWN 103
#define KEY_LEFT 100
#define KEY_RIGHT 102

typedef enum {
    FRONT, BACK, LEFT, RIGHT, UP, DOWN
} Direction;

typedef struct {
    GLfloat x;
    GLfloat y;
    GLfloat z;
} Point3D;

typedef struct {
    GLfloat r;
    GLfloat g;
    GLfloat b;
} ColorRGB;

typedef struct {
    Point3D pos;
    ColorRGB color;
} Cube;

static GLfloat angleX = 0.0f;
static GLfloat angleY = 0.0f;

static Cube cubes[4][4][4];

static GLfloat cameraX = 10.0f;
static GLfloat cameraY = 10.0f;
static GLfloat cameraZ = 10.0f;

static Direction currentDirection = FRONT;
static int currentLayer = 0;

static void initCubes() {
    int i, j, k;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            for (k = 0; k < 4; k++) {
                Cube *cube = &cubes[i][j][k];
                cube->pos.x = (i - 1.5f) * CUBE_TOTAL_SIZE;
                cube->pos.y = (j - 1.5f) * CUBE_TOTAL_SIZE;
                cube->pos.z = (k - 1.5f) * CUBE_TOTAL_SIZE;
                cube->color.r = (GLfloat) i / 4.0f;
                cube->color.g = (GLfloat) j / 4.0f;
                cube->color.b = (GLfloat) k / 4.0f;
            }
        }
    }
}

static void drawCube(Cube *cube) {
    glColor3f(cube->color.r, cube->color.g, cube->color.b);
    glPushMatrix();
    glTranslatef(cube->pos.x, cube->pos.y, cube->pos.z);
    glutSolidCube(CUBE_SIZE);
    glPopMatrix();
}

static void drawCubes() {
    int i, j, k;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            for (k = 0; k < 4; k++) {
                drawCube(&cubes[i][j][k]);
            }
        }
    }
}

static void drawAxis() {
    glBegin(GL_LINES);

    glColor3f(1.0f, 0.0f, 0.0f);
    glVertex3f(0.0f, 0.0f, 0.0f);
    glVertex3f(10.0f, 0.0f, 0.0f);

    glColor3f(0.0f, 1.0f, 0.0f);
    glVertex3f(0.0f, 0.0f, 0.0f);
    glVertex3f(0.0f, 10.0f, 0.0f);

    glColor3f(0.0f, 0.0f, 1.0f);
    glVertex3f(0.0f, 0.0f, 0.0f);
    glVertex3f(0.0f, 0.0f, 10.0f);

    glEnd();
}

static void display() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(cameraX, cameraY, cameraZ, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);

    glPushMatrix();
    glRotatef(angleX, 1.0f, 0.0f, 0.0f);
    glRotatef(angleY, 0.0f, 1.0f, 0.0f);
    drawCubes();
    glPopMatrix();

    drawAxis();

    glutSwapBuffers();
}

static void reshape(GLsizei width, GLsizei height) {
    glViewport(0, 0, width, height);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f, (GLfloat) width / (GLfloat) height, 0.1f, 100.0f);
}

static void rotateLayer(int layer, Direction direction) {
    Cube tempCubes[4][4];
    int i, j;
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            switch (direction) {
                case FRONT:
                    tempCubes[i][j] = cubes[layer][i][j];
                    break;
                case BACK:
                    tempCubes[i][j] = cubes[layer][3 - i][3 - j];
                    break;
                case LEFT:
                    tempCubes[i][j] = cubes[3 - j][layer][3 - i];
                    break;
                case RIGHT:
                    tempCubes[i][j] = cubes[j][layer][i];
                    break;
                case UP:
                    tempCubes[i][j] = cubes[i][3 - layer][3 - j];
                    break;
                case DOWN:
                    tempCubes[i][j] = cubes[i][layer][j];
                    break;
            }
        }
    }
    for (i = 0; i < 4; i++) {
        for (j = 0; j < 4; j++) {
            switch (direction) {
                case FRONT:
                    cubes[layer][i][j] = tempCubes[j][3 - i];
                    break;
                case BACK:
                    cubes[layer][i][j] = tempCubes[3 - j][i];
                    break;
                case LEFT:
                    cubes[3 - j][layer][3 - i] = tempCubes[i][j];
                    break;
                case RIGHT:
                    cubes[j][layer][i] = tempCubes[i][j];
                    break;
                case UP:
                    cubes[i][3 - layer][3 - j] = tempCubes[j][3 - i];
                    break;
                case DOWN:
                    cubes[i][layer][j] = tempCubes[j][3 - i];
                    break;
            }
        }
    }
}

static void rotateCurrentLayer(Direction direction) {
    rotateLayer(currentLayer, direction);
}

static void specialKey(int key, int x, int y) {
    switch (key) {
        case KEY_UP:
            angleX += ROTATE_STEP;
            break;
        case KEY_DOWN:
            angleX -= ROTATE_STEP;
            break;
        case KEY_LEFT:
            angleY += ROTATE_STEP;
            break;
        case KEY_RIGHT:
            angleY -= ROTATE_STEP;
            break;
    }
    glutPostRedisplay();
}

static void keyboard(unsigned char key, int x, int y) {
    switch (key) {
        case 'f':
            currentDirection = FRONT;
            currentLayer = 0;
            break;
        case 'b':
            currentDirection = BACK;
            currentLayer = 3;
            break;
        case 'l':
            currentDirection = LEFT;
            currentLayer = 0;
            break;
        case 'r':
            currentDirection = RIGHT;
            currentLayer = 3;
            break;
        case 'u':
            currentDirection = UP;
            currentLayer = 3;
            break;
        case 'd':
            currentDirection = DOWN;
            currentLayer = 0;
            break;
        case 'F':
            rotateCurrentLayer(FRONT);
            break;
        case 'B':
            rotateCurrentLayer(BACK);
            break;
        case 'L':
            rotateCurrentLayer(LEFT);
            break;
        case 'R':
            rotateCurrentLayer(RIGHT);
            break;
        case 'U':
            rotateCurrentLayer(UP);
            break;
        case 'D':
            rotateCurrentLayer(DOWN);
            break;
        case 'q':
            exit(0);
            break;
    }
    glutPostRedisplay();
}

int main(int argc, char **argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    glutCreateWindow("4x4x4 Rubik's Cube");

    initCubes();

    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutSpecialFunc(specialKey);
    glutKeyboardFunc(keyboard);

    glEnable(GL_DEPTH_TEST);

    glutMainLoop();

    return 0;
}

首先，我们需要定义一些常量和数据结构。在这个示例中，我们定义了窗口的大小，每个小方块的大小，旋转步长，方向和颜色等信息。我们使用一个三维数组 `cubes` 来存储所有的小方块，每个方块包含了位置和颜色信息。

接下来，我们需要实现一些绘制函数。`drawCube` 函数用于绘制一个小方块，`drawCubes` 函数用于绘制所有的小方块，`drawAxis` 函数用于绘制坐标轴。在 `display` 函数中，我们使用 OpenGL 的矩阵操作来控制摄像机位置和旋转角度，然后分别调用上述绘制函数来绘制场景。

我们还需要实现一些交互函数。`rotateLayer` 函数用于旋转一个层，`rotateCurrentLayer` 函数用于旋转当前选中的层，`specialKey` 函数用于响应特殊按键事件（如方向键），`keyboard` 函数用于响应普通按键事件（如字母键）。在 `main` 函数中，我们创建窗口并注册这些函数，然后进入主循环。

这段代码只是一个示例，可能不够完整和健壮。如果你想要学习更多关于 OpenGL 和 GLUT 的内容，可以参考一些教程和书籍，如《OpenGL Programming Guide》和《OpenGL SuperBible》等。

输入两个整数，交换位置后输出。 输入格式: 在一行中用空格分隔输入两个整数a，b。 输出格式: 交换a，b的值后，按“a=? b=?”的格式输出

当你需要编写一个程序来接收用户输入的两个整数a和b，然后交换它们的位置并输出结果时，你可以按照以下步骤进行：

1. 首先，从标准输入读取这两个整数，例如`scanf`在C语言中，或`Scanner.nextInt()`在Java中。

2. 接收完后，创建两个临时变量存储这两个数值，通常将a的值赋给第一个临时变量，将b的值赋给第二个。

3. 然后，将b的值赋回原a的位置，将刚才存有a值的临时变量赋给b。

4. 最后，按照指定的格式输出修改后的值，即打印`"a=? b=?"`，这里的`?`分别替换为交换后的a和b的值。

下面是一个简单的C++示例代码片段：

#include <iostream>
using namespace std;

int main() {
    int a, b;
    cin >> a >> b; // 读取用户输入

    int temp = a; // 创建临时变量
    a = b;
    b = temp; // 交换值

    cout << "a=" << a << " b=" << b << endl; // 输出交换后的值

    return 0;
}

如果你需要在Java中实现类似功能，可以参考下面的代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入两个整数a 和 b, 以空格分隔：");
        int a = scanner.nextInt();
        int b = scanner.nextInt();

        int temp = a;
        a = b;
        b = temp;

        System.out.printf("a=%d b=%d%n", a, b); // 输出格式化字符串
        scanner.close();
    }
}