Haben Sie Probleme, diesen PRNG-Code in c zu verstehen

Question

generasacodicetagpre.

Dies ist ein Teil des Codes für eine PRNG.Ich bin nicht sehr erfahren mit c und einige der Dinge in diesem Code machen für mich absolut keinen Sinn.Ich habe versucht, zu code zu kommentieren, um zu verfolgen, was los ist.Ich würde es schätzen, wenn einige der Dinge, die ich nicht verstehe, gelöscht werden kann.Insbesondere die Deklarationen von Variablen und Funktionen mit demselben Namen sowie der Initrnd-Subroutine, die nicht im Programm oder in der Bibliothek definiert werden, die ich im Internet finden konnte.

vielen dank.

Answer 1

This looks positively ancient.

A few answers to your questions:

1. No, prototypes don't need to be outside functions. It's most common, perhaps, but not required.
2. initrnd() just sets the global seed variable to a specific value, that is then used in the PRNG.
3. The data is written to stdout; which is assumed to be using file descriptor 1. This use of a magical constant is not very pretty, it should be written as stdout (from <stdio.h>).

Answer 2

   /* type cast, why?? */
   sd = (double)(ne);

because ne is an integer and sd is a double, therefore the cast is needed

   /* no idea what initrnd does */
   initrnd(sd/(sd+187.9753));

it is the last function, it sets the global variable seed with its parameter

   /* writes the buffer, how does it know the file name? */ 
   write(1, buf, ne*sf);

the file descriptor is 1, which stands for standard output, so this is like calling printf()

initrnd(sd)

/* again no idea, why isn't this function void */

this function is int, but it should be void (it doesn't make any difference anyway), perhaps the original programmer was lazy :P

Answer 3

The code is pre-standard C, so it's not using prototypes (but does declare functions, though apparently not unless absolutely necessary). The function definitions use the pre-standard K&R style of declaring the parameters to the function. With non-protoyped functions, it incumbent on the programmer to ensure that the functions are called with the correct set of arguments, and that if a function returns nothing, then nothing is done with the function's 'value'.

If something other than an int is returned from a function, then the function must be declared (which is not necessarily a prototype) so the compiler is aware of the type of data returned from the function. Without a declaration, the compiler will assume that an int is returned (but if nothing is returned by the function, that's OK as long as you don't try to do anything with the function 'result').

Here are some direct comments to your questions:

   /* prototypes? ( shouldn't they be outside the main ) */
   //   this declares that function `rnd()` returns a double.  Technically, it's 
   //   not a prototype. Without the declaration the compiler would assume that it 
   //   returns an `int` so trying to use it wouldn't work.  It could be declared 
   //   outside `main()`, but it's OK to have it declared within the scope of 
   //   `main()`, just like it would be for a prototype.  That just means that 
   //    outside of `main()` the declaration is no longer in effect, so any calls
   //    to `rnd()` would assume that `int` is returned (incorrectly).
   double rnd(), sd;


   /* type cast, why?? */
   //   the cast is unnecessary and redundant, but OK
   sd = (double)(ne);

   /* no idea what initrnd does */
   //   apparently `initrnd()` initializes the rng seed (see below). There's
   //   no declaration in sight, so the compiler will default the return type 
   //   to `int` (unless it's in `stdio.h`).
   initrnd(sd/(sd+187.9753));

   /* writes the buffer, how does it know the file name? */ 
   //   `1` is the file descriptor for `stdout`.  Today this would probably
   //   be specified using `STDOUT_FILENO`, but even today `STDOUT_FILENO` is 
   //   required to be 1 (by POSIX).
   write(1, buf, ne*sf);
}

initrnd(sd)

/* again no idea, why isn't this function void */
//  `void` didn't exist pre-ANSI standard.
//  so this function 'returns' `int` by default.
double sd;
{
seed = sd;
return(0);
}