C: Цикличное выполнение, не используя инструкции цикла или рекурсию

Я очень разочарован, что это не работает. На мой взгляд, фраза «функция вызывается после любых ранее зарегистрированных функций, которые уже были вызваны во время регистрации» предполагает, что можно зарегистрировать обработчики atexit после того, как они начали вызываться. То есть обработчик может зарегистрировать другой обработчик. В противном случае, как вообще может существовать функция, которая была вызвана во время регистрации другой функции? Но для меня вызов atexit возвращает 0 успехов, но на самом деле не приводит к другому вызову. Кто-нибудь знает, почему, я сделал какую-то глупую ошибку?

#include "stdio.h"
#include "stdlib.h"

int count = 0;
int limit = 10;

void handler() {
    printf("%d of %d\n", ++count, limit);
    if (count < limit) atexit(handler);
}

int main(int argc, char **argv) {
    if (argc > 1) limit = atoi(argv[1]);
    atexit(handler);
}

Между прочим, не рекурсия, потому что atexit не вызывает свой параметр, а ставит его в очередь для последующего вызова. Очевидно, среда выполнения C содержит цикл для вызова обработчиков atexit, но этот цикл существует независимо от того, зарегистрируете ли вы какие-либо обработчики atexit или нет. Итак, если эта программа содержит цикл, то же самое и каждая программа на C; -)

Еще одна вещь (в linux) - это сделать, как показано ниже, где 7 - это N

int main() {
    return system("seq 7");
}

сначала записывает весь возможный вывод в строку и завершает ее нулевым символом там, где вывод должен остановиться.
это довольно грязное решение, но с учетом ограничений, все, что я могу придумать,
, за исключением использования ассемблера, конечно.

char a[]="1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n"/*...*/;
main(n,v)char**v;{n=atoi(v[1]);
#define c(x)(n>x?n-x:0)
a[n+c(1)+c(9)+c(99)+c(999)+c(9999)+c(99999)+c(999999)+c(9999999)/*+...*/]=0;
puts(a);}

Учитывая, что MAX_INT == 2147483647 на популярных архитектурах, нам нужно только подняться до + c (999999999) . Однако набор этой начальной строки может занять некоторое время ...

Для этого можно использовать функции setjmp и logjmp, как показано в этом FAQ по C

. Для тех, кому интересно, почему у кого-то возникает такой вопрос, это один из часто задаваемые вопросы в Индии при приеме на работу выпускников.

This takes the integer N from the command line and prints out from 1 to N

#include <stdio.h>
#include <stdlib.h>

int total;
int N;

int print16(int n)
{
    printf("%d\n",n+0x01); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x02); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x03); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x04); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x05); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x06); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x07); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x08); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x09); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0A); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0B); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0C); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0D); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0E); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x0F); total++; if (total >= N) exit(0);
    printf("%d\n",n+0x10); total++; if (total >= N) exit(0);
}

int print256(int n)
{
    print16(n);
    print16(n+0x10);
    print16(n+0x20);
    print16(n+0x30);
    print16(n+0x40);
    print16(n+0x50);
    print16(n+0x60);
    print16(n+0x70);
    print16(n+0x80);
    print16(n+0x90);
    print16(n+0xA0);
    print16(n+0xB0);
    print16(n+0xC0);
    print16(n+0xD0);
    print16(n+0xE0);
    print16(n+0xF0);
}

int print4096(int n)
{
    print256(n);
    print256(n+0x100);
    print256(n+0x200);
    print256(n+0x300);
    print256(n+0x400);
    print256(n+0x500);
    print256(n+0x600);
    print256(n+0x700);
    print256(n+0x800);
    print256(n+0x900);
    print256(n+0xA00);
    print256(n+0xB00);
    print256(n+0xC00);
    print256(n+0xD00);
    print256(n+0xE00);
    print256(n+0xF00);
}

int print65536(int n)
{
    print4096(n);
    print4096(n+0x1000);
    print4096(n+0x2000);
    print4096(n+0x3000);
    print4096(n+0x4000);
    print4096(n+0x5000);
    print4096(n+0x6000);
    print4096(n+0x7000);
    print4096(n+0x8000);
    print4096(n+0x9000);
    print4096(n+0xA000);
    print4096(n+0xB000);
    print4096(n+0xC000);
    print4096(n+0xD000);
    print4096(n+0xE000);
    print4096(n+0xF000);
}

int print1048576(int n)
{
    print65536(n);
    print65536(n+0x10000);
    print65536(n+0x20000);
    print65536(n+0x30000);
    print65536(n+0x40000);
    print65536(n+0x50000);
    print65536(n+0x60000);
    print65536(n+0x70000);
    print65536(n+0x80000);
    print65536(n+0x90000);
    print65536(n+0xA0000);
    print65536(n+0xB0000);
    print65536(n+0xC0000);
    print65536(n+0xD0000);
    print65536(n+0xE0000);
    print65536(n+0xF0000);
}

int print16777216(int n)
{
    print1048576(n);
    print1048576(n+0x100000);
    print1048576(n+0x200000);
    print1048576(n+0x300000);
    print1048576(n+0x400000);
    print1048576(n+0x500000);
    print1048576(n+0x600000);
    print1048576(n+0x700000);
    print1048576(n+0x800000);
    print1048576(n+0x900000);
    print1048576(n+0xA00000);
    print1048576(n+0xB00000);
    print1048576(n+0xC00000);
    print1048576(n+0xD00000);
    print1048576(n+0xE00000);
    print1048576(n+0xF00000);
}

int print268435456(int n)
{
    print16777216(n);
    print16777216(n+0x1000000);
    print16777216(n+0x2000000);
    print16777216(n+0x3000000);
    print16777216(n+0x4000000);
    print16777216(n+0x5000000);
    print16777216(n+0x6000000);
    print16777216(n+0x7000000);
    print16777216(n+0x8000000);
    print16777216(n+0x9000000);
    print16777216(n+0xA000000);
    print16777216(n+0xB000000);
    print16777216(n+0xC000000);
    print16777216(n+0xD000000);
    print16777216(n+0xE000000);
    print16777216(n+0xF000000);
}

int print2147483648(int n)
{
   /*
    * Only goes up to n+0x70000000 since we
    * deal only with postive 32 bit integers
    */
   print268435456(n);
   print268435456(n+0x10000000);
   print268435456(n+0x20000000);
   print268435456(n+0x30000000);
   print268435456(n+0x40000000);
   print268435456(n+0x50000000);
   print268435456(n+0x60000000);
   print268435456(n+0x70000000);
}


int main(int argc, char *argv[])
{
   int i;

   if (argc > 1) {
      N = strtol(argv[1], NULL, 0);
   }

   if (N >=1) {
      printf("listing 1 to %d\n",N);
      print2147483648(0);
   }
   else {
      printf("Must enter a postive integer N\n");
   }
}

Это можно сделать, вложив макросы.

int i = 1;

#define PRINT_1(N) if( i < N ) printf("%d\n", i++ );
#define PRINT_2(N) PRINT_1(N) PRINT_1(N)
#define PRINT_3(N) PRINT_2(N) PRINT_2(N)
#define PRINT_4(N) PRINT_3(N) PRINT_3(N)
:
:
#define PRINT_32(N) PRINT_31(N) PRINT_31(N)

Всего будет 32 макроса. Предполагая, что размер int равен 4 байтам. Теперь вызовите PRINT_32 (N) из любой функции.

Изменить: Добавляем пример для ясности.

void Foo( int n )
{
    i = 1;

    PRINT_32( n );
}


void main()
{
    Foo( 5 );
    Foo( 55 );
    Foo( 555 );
    Foo( 5555 );
}

Я бы использовал longjmp ()

#include <stdio.h>
#include <setjmp.h>

void do_loop(int n) {
  int val;
  jmp_buf env;

  val = 0;

  setjmp(env);

  printf("%d\n", ++val);

  if (val != n)
    longjmp(env, 0);  
}

int main() {
  do_loop(7);
  return 0;
}

N не зафиксировано, поэтому вы не можете развернуть цикл. Насколько мне известно, в C нет итераторов.

Вы должны найти что-нибудь, имитирующее цикл.

Или нестандартное мышление:

(например, N ограничено 1000, но его легко адаптировать)

int f(int N) {
    if (N >= 900) f100(100);
    if (N >= 800) f100(100);
    if (N >= 700) f100(100);
    ...

    f100(n % 100);
}

int f100(int N) {
    if (N >= 90) f10(10);
    if (N >= 80) f10(10);
    if (N >= 70) f10(10);
    ...

    f(n % 10);
}

int f10(int N) {
    if (N >= 9) func();
    if (N >= 8) func();
    if (N >= 7) func();
    ...
}

Вот и все:

int main ()
{
printf ("1 to N one per each line\n");
return 0;
}

Вот еще один:

#include <stdlib.h>
#include <stdio.h>

int main (int c, char ** v) {
    char b[100];
    sprintf (b, "perl -e 'map {print \"$_\\n\"} (1..%s)'", v[1]);
    system (b);
    return 0;
}

Если вы знаете верхний предел N, вы можете попробовать что-то вроде этого ;)

void func(int N)
{
    char *data = " 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n10\n11\n12\n";
    if (N > 0 && N < 12)
        printf("%.*s", N*3, data);
    else
        printf("Not enough data. Need to reticulate some more splines\n");
}

Шутка в сторону, я действительно не понимаю, как это можно сделать без рекурсии или всех инструкций, которые вы там упомянули. Это заставляет меня интересоваться решением.

Edit : Только что заметил, что я предложил то же решение, что и grombeestje :)

В Oracle местоположение, содержащее информацию обо всех объектах базы данных, включая таблицы и хранимые процедуры, называется словарем данных. Это набор представлений, который предоставляет вам доступ к метаданным, определяющим базу данных. Вы можете запросить в представлениях словаря данных список желаемых объектов базы данных, а затем использовать функции, доступные в пакете dbms_metadata , чтобы получить DDL для каждого объекта. Альтернативой является изучение поддержки в dbms_metadata экспорта DDL для коллекции объектов.

Для нескольких указателей, например, для получения списка таблиц, вы можете использовать следующие представления словаря данных

• user_tables содержит все таблицы, принадлежащие пользователю
• all_tables содержат все таблицы, к которым имеет доступ пользователь
• и так далее ...

#include <stdlib.h>

int callback(const void *a, const void *b) {
    static int n = 1;

    if (n <= N)
        printf("%d\n", n++);

    return 0;
}

int main(int argc, char *argv) {
    char *buf;
    /* get N value here */

    buf = malloc(N);  // could be less than N, but N is definitely sufficient
    qsort(buf, N, 1, callback);
}

Я думаю, что это не считается рекурсией.

    /// <summary>
    /// Print one to Hundred without using any loop/condition.
    /// </summary>
    int count = 100;
    public void PrintOneToHundred()
    {
        try
        {
            int[] hey = new int[count];
            Console.WriteLine(hey.Length);
            count--;
            PrintOneToHundred();
        }
        catch
        {
            Console.WriteLine("Done Printing");
        }
    }