C++中带默认参数的auto Lambda输入函数报错问题咨询

Hey there! Let's figure out how to replicate Python's handy input() function in C++—I totally get why you'd want that seamless input experience. Let's break down what's tripping up your auto lambda with default parameters, and fix it properly.

The Core Issue with Your Lambda Approach #

First, let's ground this in C++'s static typing rules: unlike Python (dynamic typing), every C++ function (including lambdas) needs a fixed return type—or needs to be a template so the compiler can deduce the type at call time.

If you wrote something like this (a common attempt that throws errors):

// This will fail to compile!
auto input = [](std::string prompt = "", auto type = int{}) {
    std::cout << prompt;
    decltype(type) val;
    std::cin >> val;
    return val;
};

The compiler complains because:

• The auto return type of the lambda gets locked to int based on the default parameter int{}.
• If you try to call it with a different type (like input("", double{})), the lambda can't suddenly switch its return type—C++ doesn't allow that for non-template functions.

Solutions to Mimic Python's input() #

Let's cover two solid approaches, depending on your C++ version.

1. Template Function (C++11 and Later) #

This is the most compatible option, and it lets you specify (or default to) the type you want to return:

#include <iostream>
#include <string>
#include <stdexcept>
#include <limits>

template<typename T = int>
T input(const std::string& prompt = "") {
    std::cout << prompt;
    T val;
    std::cin >> val;

    // Add input validation to handle bad inputs (e.g., typing a letter for an int)
    if (!std::cin) {
        std::cin.clear(); // Reset error state
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Discard bad input
        throw std::invalid_argument("Invalid input for the requested type");
    }

    return val;
}

How to use it:

• Default to int: int age = input("Enter your age: "); or just int num = input();
• Get a double: double price = input<double>("Enter item price: ");
• Get a string (note: stops at whitespace): std::string username = input<std::string>("Enter username: ");

2. C++20 Template Lambda (Shorter Syntax) #

If you're using C++20 or newer, you can use a template lambda for a more concise implementation:

#include <iostream>
#include <string>
#include <stdexcept>
#include <limits>

auto input = []<typename T = int>(const std::string& prompt = "") {
    std::cout << prompt;
    T val;
    std::cin >> val;

    // Same input validation as above
    if (!std::cin) {
        std::cin.clear();
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        throw std::invalid_argument("Invalid input type");
    }

    return val;
};

Usage is identical to the template function—just call input() for int, input<double>() for decimals, etc.

Bonus: Replicate Python's Exact input() (Return String First) #

Python's input() returns a string, which you then convert to other types. If you want that exact workflow, split it into two functions:

#include <iostream>
#include <string>
#include <sstream>
#include <stdexcept>

// Returns raw input as a string (reads entire line)
std::string input_str(const std::string& prompt = "") {
    std::cout << prompt;
    std::string val;
    std::getline(std::cin, val);
    return val;
}

// Converts the string to your desired type
template<typename T>
T convert_input(const std::string& s) {
    std::stringstream ss(s);
    T val;
    ss >> val;

    // Ensure the entire string was converted (no leftover characters)
    if (!ss.eof() || ss.fail()) {
        throw std::invalid_argument("Failed to convert string to target type");
    }

    return val;
}

Usage:

std::string age_str = input_str("Enter your age: ");
int age = convert_input<int>(age_str);

Why Your Original Lambda Failed #

To recap:

• Your auto lambda without template parameters gets its return type deduced once at definition time (from the default int parameter).
• C++ doesn't allow a single non-template function to return different types based on runtime or call-time arguments—unlike Python's dynamic typing system.
• Template functions/lambdas fix this by generating a separate function instance for each type you request.

内容的提问来源于stack exchange，提问作者Moses Wescombe