Как получить целочисленный и плавающий ввод без `scanf()` в c?

Нет функций для чтения целых чисел и чисел с плавающей запятой, но вы можете использовать fgets с strtol для целых чисел и strtof для чисел с плавающей запятой:

// floats:
char str_f[20];
float f;

fgets (str_f, 20, stdin);
f = strtof(str_f, NULL);

// integers:
char str_i[20];
int i;

fgets(str_i, 20, stdin);
i = strtol(str_i, NULL, 0);

Вы также можете использовать atoi для целых чисел, но это не рекомендуется, поскольку atoi не обнаруживает ошибок и считается устаревшим.

Если вы хотите обнаружить ошибки, вы можете использовать следующий код:

// floats:
char *endptr_f;
char str_f[20];
float f;

fgets (str_f, 20, stdin);
f = strtof(str_f, &endptr_f);

if (*endptr_f != '\n' || str_f[0] == '\n' || endptr_f == str_f)
{
    printf("ERROR: \"%s\" is an invalid float!\n", str_f);
}

// integers:
char *endptr_i;
char str_i[20];
int i;

fgets(str_i, 20, stdin);
i = strtol(str_i, &endptr_i, 0);

if (*endptr_i != '\n' || str_i[0] == '\n' || endptr_i == str_i)
{
    printf("ERROR: \"%s\" is an invalid integer!\n", str_i);
}

Много лет назад я написал это, протестировал в VS2017 и до сих пор работает. Очень просто, не очень хорошо, но, может быть, вы можете использовать его для чего-то

#define INT_CONVERTED       (1 << 0)
#define FLOAT_CONVERTED     (1 << 1)

char *strlwr(char *str)
{
    char *ptr = str;

    while (*ptr)
    {
        *ptr = tolower(*ptr);
        ptr++;
    }
    return str;
}


int NumberOfDots(char *s)
{
    int dots = 0;
    while (*s)
        dots += *s++ == '.';
    return dots;
}

int NOTstrcasechr(char *str, int ch)
{
    return strchr(str, ch) == NULL && strchr(str, toupper(ch)) == NULL;
}

int ReadNumber(double *db, int *in)
{
    int result = 0;

    do
    {
        char str[100];
        int dots;

        result = 0;
        printf("Enter number: ");
        fgets(str, 100, stdin);
        if ((dots = NumberOfDots(str)) > 1) str[0] = '\0';

        if (sscanf(str, "%lf", db) == 1)
        {
            result |= FLOAT_CONVERTED;
        }
        if (!result || (!dots && NOTstrcasechr(str, 'e')))
            if (NOTstrcasechr(str, 'x'))
            {
                if (sscanf(str, "%d", in) == 1)
                {
                    result |= INT_CONVERTED;
                }
            }
            else 
                if(result)
                {
                    result |= INT_CONVERTED;
                    *in = (int)*db;
                }
        if (strstr(strlwr(str), "exit") != NULL) result = -1;

    } while (!result);
    return result;
}


int main(int argc, char **argv)
{
    double db;
    int in;
    int result;

    while ((result = ReadNumber(&db, &in)) != -1)
    {

        if (result & FLOAT_CONVERTED) printf("Float = %lf ", db);
        if (result & INT_CONVERTED) printf("Integer = %d ", in);
        printf("\n\r");

    }
    return 0;
}

Enter number: xfdsfdsfdsf
Enter number: rthdgfhghg
Enter number: 0x4567
Float = 17767.000000 Integer = 17767
Enter number: 3e67
Float = 30000000000000000978680950144401383192292617328216608963406365458432.000000
Enter number: 54567
Float = 54567.000000 Integer = 54567
Enter number: dfgdfgdfgdfgdgg
Enter number: 3456
Float = 3456.000000 Integer = 3456
Enter number: 12354654465454654654565567567576
Float = 12354654465454653961713368432640.000000 Integer = -1
Enter number: exit

Есть ли функция для чисел с плавающей запятой и целых чисел?

Да, это scanf(), но OP не хочет его использовать.

Как получить целочисленный и плавающий ввод без scanf()?

Это не тривиальная задача, как scanf("%d", &some_int), scanf("%f", &some_float).

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

Вместо этого обсуждалась проблема чтения строки пользовательского ввода для одного целого числа long. Чтение float аналогично. Необходимы изменения возле строк ***

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

Переполнение — это проблема, которая в некоторой степени рассматривается здесь. Напомним, что с scanf() поведение OF/UF не определено.

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

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

// character array size needed to represent all `long`
#define INT_STR_SIZE (sizeof(long)*CHAR_BIT/3 + 3)
#define INT_BUF_SIZE (INT_STR_SIZE*2)

int readline_long(long *dest) {                        // ***
  int ch;
  while (isspace(ch = getchar()) && ch != '\n') {
    ;
  }
  if (ch == EOF) return EOF;
  ungetc(ch, stdin);

  char buf[INT_BUF_SIZE];                                 // ***
  if (fgets(buf, sizeof buf, stdin) == NULL) return EOF;
  if (strchr(buf, '\n') == NULL) {
    // Get rest of line
    bool only_white_space = true;
    while ((ch = getchar()) != '\n' && ch != EOF) {
      if (!isspace(ch)) only_white_space = false; // consume rest of line
    }
    if (!only_white_space) return 0;  // extra junk
  }
  char *endptr;
  errno = 0;
  long y = strtol(buf, &endptr, 10);                    // ***
  if (buf == endptr) return false;  // no conversion
  while (isspace((unsigned char) *endptr)) {
    endptr++;
  }
  if (*endptr) return 0; // extra junk
  *dest = y;
  return 1;
}

Тестовый код

int main(void) {
  long lg;
  int retval;
  while ((retval = readline_long(&lg)) != EOF) {
    printf("retval = %d", retval);
    if (retval > 0) printf(" val = %ld", lg);
    if (errno) printf(" errno = %d", errno);
    putchar('\n');
    fflush(stdout);
  }
}