用指针实现:产生斐波那契数列的前20项。要求每输出数换一行。

以下是用指针实现斐波那契数列的前20项的代码：

#include <iostream>
using namespace std;

void fibonacci(int *arr, int n)
{
    arr[0] = 0;
    arr[1] = 1;
    for (int i = 2; i < n; i++) {
        arr[i] = arr[i-1] + arr[i-2];
    }
}

int main()
{
    int arr[20];
    fibonacci(arr, 20);
    for (int i = 0; i < 20; i++) {
        cout << arr[i] << endl;
    }
    return 0;
}

这里定义了一个 `fibonacci` 函数来生成斐波那契数列，该函数使用指针来操作数组。在 `main` 函数中，我们定义了一个大小为20的数组 `arr`，并将其传递给 `fibonacci` 函数来填充数组。最后，我们使用循环来输出数组中的元素，并在每个数字后换行。

相关问题

汇编语言输出斐波那契数列前20项

下面是用 x86 汇编语言输出斐波那契数列前20项的代码：

section .data
    fib db 0, 1      ; 斐波那契数列的前两项

section .text
    global _start
_start:
    ; 输出斐波那契数列的第一项
    mov eax, [fib]
    call print_num
    mov eax, 10      ; 换行符的 ASCII 码
    call print_char

    ; 输出斐波那契数列的第二项
    mov eax, [fib + 1]
    call print_num
    mov eax, 10      ; 换行符的 ASCII 码
    call print_char

    ; 输出斐波那契数列的剩余18项
    mov ecx, 18      ; 循环计数器
    mov ebx, [fib]   ; ebx 存储当前项的值
    mov edx, [fib + 1] ; edx 存储下一项的值
next_fib:
    add ebx, edx     ; 计算下一项的值
    mov eax, ebx     ; 将下一项的值赋给 eax
    call print_num
    mov eax, 10      ; 换行符的 ASCII 码
    call print_char

    ; 更新 fib 数组的值
    mov [fib], edx
    mov [fib + 1], ebx
    loop next_fib

    ; 退出程序
    mov eax, 1
    xor ebx, ebx
    int 0x80

; 输出一个数字
print_num:
    push eax         ; 保存 eax 的值
    push ebx         ; 保存 ebx 的值
    push ecx         ; 保存 ecx 的值

    mov ecx, 0       ; 将 ecx 置为 0，作为循环计数器
    mov ebx, 10      ; ebx 存储 10，用于对数字进行除法和取模运算
.loop:
    xor edx, edx     ; 将 edx 置为 0
    div ebx          ; edx 存储余数，eax 存储商
    push edx         ; 将余数压入栈中
    inc ecx          ; 循环计数器加 1
    test eax, eax    ; 如果 eax 等于 0，跳出循环
    jnz .loop

    ; 从栈中弹出余数，输出数字
.print:
    pop eax          ; 将余数存入 eax
    add eax, 48      ; 将数字的 ASCII 码加上 48
    mov [num], al    ; 将数字的 ASCII 码存入 num 变量
    mov eax, 4       ; 系统调用编号为 4，表示输出字符串
    mov ebx, 1       ; 文件描述符为 1，表示标准输出
    mov ecx, num     ; 字符串指针
    mov edx, 1       ; 输出字符串长度为 1
    int 0x80

    ; 如果还有余数，继续输出数字
    dec ecx          ; 循环计数器减 1
    jnz .print

    ; 恢复寄存器的值
    pop ecx
    pop ebx
    pop eax
    ret

; 输出一个字符
print_char:
    mov [char], al   ; 将字符存入 char 变量
    mov eax, 4       ; 系统调用编号为 4，表示输出字符串
    mov ebx, 1       ; 文件描述符为 1，表示标准输出
    mov ecx, char    ; 字符串指针
    mov edx, 1       ; 输出字符串长度为 1
    int 0x80
    ret

section .bss
    num resb 1       ; 存储数字的 ASCII 码
    char resb 1      ; 存储字符的 ASCII 码

这段代码使用了 x86 的汇编语言，在 Linux 系统上运行。它使用了一个 fib 数组来存储斐波那契数列的前两项，然后使用循环计算并输出斐波那契数列的剩余18项。在输出数字时，它采用了将数字转换为字符串的方法，然后输出字符串的方式。

汇编程序用子程序计算斐波那契数列，要求输入数字n可以计算n阶斐波那契数列的值

好的，下面是汇编程序，使用子程序计算斐波那契数列：

.data
n dw ? ; 输入的数值n
result dw ? ; 结果存储变量

.code
main proc
    mov ax, @data
    mov ds, ax ; 初始化数据段寄存器

    ; 读取输入的数值n
    mov ah, 0ah ; 功能号0ah，读取字符串
    mov dx, offset n ; 存储字符串的偏移地址
    int 21h ; 调用中断

    ; 将输入的字符串转换为数值
    mov si, offset n + 2 ; 跳过输入的长度和换行符
    call ascii_to_num ; 调用子程序

    ; 计算斐波那契数列
    mov ax, 0 ; F(0) = 0
    mov bx, 1 ; F(1) = 1
    mov cx, result ; 存储结果的变量
    mov dx, n ; 循环计数器
    call fibonacci ; 调用子程序

    ; 输出结果
    mov ax, cx ; 将结果存储变量中的值读取到ax中
    call write_dec ; 输出结果到屏幕
    call crlf ; 输出换行符

    mov ah, 4ch
    int 21h ; 程序结束
main endp

; 子程序：将ASCII码字符串转换为数值
ascii_to_num proc
    push ax
    push bx
    push cx
    push dx

    xor ax, ax ; ax = 0
    mov cx, 10 ; cx = 10
L1:
    mov bx, 10 ; bx = 10
    mul bx ; ax = ax * 10
    mov bl, [si] ; 取出当前字符
    sub bl, '0' ; 转换为数值
    add ax, bx ; ax = ax + bx
    inc si ; 字符指针加1
    loop L1 ; 循环至n次

    mov result, ax ; 将转换后的数值存储到结果变量中

    pop dx
    pop cx
    pop bx
    pop ax
    ret
ascii_to_num endp

; 子程序：计算斐波那契数列
fibonacci proc
    push ax
    push bx
    push cx
    push dx

L1:
    cmp dx, 0 ; n == 0?
    je L2 ; 跳转到L2
    mov cx, ax ; cx = F(i-1)
    add ax, bx ; ax = F(i-1) + F(i-2)
    mov bx, cx ; bx = F(i-1)
    dec dx ; n -= 1
    jmp L1 ; 继续循环

L2:
    mov cx, ax ; 将结果存储到结果变量中

    pop dx
    pop cx
    pop bx
    pop ax
    ret
fibonacci endp

; 子程序：输出十进制数值
write_dec proc
    push ax
    push bx
    push cx
    push dx

    xor bx, bx ; bx = 0
    mov cx, 10 ; cx = 10
L1:
    xor dx, dx ; dx = 0
    div cx ; ax = ax / 10, dx = ax % 10
    push dx ; 压入余数
    inc bx ; bx += 1
    or ax, ax ; ax == 0?
    jnz L1 ; 不为0，继续循环

L2:
    pop dx ; 取出余数
    add dl, '0' ; 转换为ASCII码
    mov ah, 02h ; 功能号2，输出字符
    int 21h ; 调用中断
    dec bx ; bx -= 1
    jnz L2 ; bx 不为0，继续循环

    pop dx
    pop cx
    pop bx
    pop ax
    ret
write_dec endp

; 子程序：输出换行符
crlf proc
    mov dl, 0dh ; ASCII码0d，回车符
    mov ah, 02h ; 功能号2，输出字符
    int 21h ; 调用中断

    mov dl, 0ah ; ASCII码0a，换行符
    mov ah, 02h ; 功能号2，输出字符
    int 21h ; 调用中断

    ret
crlf endp

以上程序使用了四个子程序：`ascii_to_num`，`fibonacci`，`write_dec` 和 `crlf`。`ascii_to_num` 用于将输入的ASCII码字符串转换为数值，`fibonacci` 则用于计算斐波那契数列的值，`write_dec` 用于将一个十进制数值输出到屏幕上，`crlf` 则用于输出换行符。主程序中使用了两个变量：`n` 存储输入的数值，`result` 存储计算结果。首先读取输入的数值，并调用 `ascii_to_num` 子程序将输入的字符串转换为数值。然后调用 `fibonacci` 子程序计算斐波那契数列，并将结果存储到 `result` 变量中。最后调用 `write_dec` 和 `crlf` 子程序将结果输出到屏幕上。