#define print(msg) std：：cout << msg << std：：endl

#define print(msg) std::cout << msg << std::endl

本文关键字：lt std msg print endl #define cout      更新时间：2023-10-16

我最近开始使用C++，我有一种强烈的冲动

#define print(msg) std::cout << msg << std::endl

这在所有情况下都能正确执行吗？ 这是我所知道的唯一一种在味精中出现<<时会起作用的公式(例如 "foo" << myInt (。 也不

#define print(msg) std::cout << (msg) << std::endl // note: parens

也不是建议的答案

template<typename T>
void print(T const& msg) {
    std::cout << msg << std::endl;
}

在这种情况下工作。 我也不关心用endl刷新输出的效率与仅使用n。

既然你提到你最近才开始使用C++，我想向你展示该语言提供的更好的替代方案：

template<typename T>
void print(T const& msg)
{
    std::cout << msg << std::endl;
}

它接受任何类型的单个msg参数，并通过std::cout将其流式传输出去。

如注释中所述，std::endl不仅插入新行，还会刷新流。这类似于printf n冲洗。如果你只是想要一个新行，你可能想要，最好明确地这样做：

std::cout << msg << 'n';

这是非常主观的，但是您编写一次代码并多次阅读。代码的其他维护者会想要理解你写了什么，所以只要写std::cout << msg << std::endl你的意思。不要试图C++看起来像另一种语言。

只是为了好玩，这里有两个print的可变参数C++11实现：一个在参数之间插入空格，另一个不插入。 (住在 ideone。

#include <iostream>
namespace with_spaces {
namespace detail {
std::ostream& print(std::ostream& os) {
    return os;
}
template <typename T>
std::ostream& print(std::ostream& os, T&& t) {
    return os << std::forward<T>(t);
}
template <typename T, typename U, typename... Args>
std::ostream& print(std::ostream& os, T&& t, U&& u, Args&&... args) {
    return print(print(os, std::forward<T>(t)) << ' ', std::forward<U>(u), std::forward<Args>(args)...);
}
}
template <typename... Args>
void print(Args&&... args) {
    detail::print(std::cout, std::forward<Args>(args)...) << std::endl;
}
}
namespace without {
namespace detail {
std::ostream& print(std::ostream& os) {
    return os;
}
template <typename T>
std::ostream& print(std::ostream& os, T&& t) {
    return os << std::forward<T>(t);
}
template <typename T, typename... Args>
std::ostream& print(std::ostream& os, T&& t, Args&&... args) {
    return print(print(os, std::forward<T>(t)), std::forward<Args>(args)...);
}
}
template <typename... Args>
void print(Args&&... args) {
    detail::print(std::cout, std::forward<Args>(args)...) << std::endl;
}
}
#include <iomanip>
int main() {
    std::cout << std::boolalpha;
    with_spaces::print(1, "foo", new int(3), 0xFFFFFFFFFFULL, 42, 0 == 1);
    without::print(1, "foo", new int(3), 0xFFFFFFFFFFULL, 42, 0 == 1);
}

对我来说有趣的是，完成简单的单行宏可以执行的操作需要多少代码。

宏

被广泛使用，但不是很好的做法(尤其是在C++中(，因为它们可以隐藏真实发生的事情，并使调试代码变得不可能。

宏还会绕过预处理器的类型检查，并可能导致运行时问题。

如果您正在尝试优化速度，我会在这里建议使用内联函数。

相关文章：