Я долгое время программировал на С++. Я всегда задавался вопросом, какая из них имеет более быструю скорость выполнения printf или cout?
Ситуация: Я разрабатываю приложение на С++, и у меня есть определенные ограничения, такие как ограничение по времени для выполнения. В моем приложении загружаются команды печати на консоли. Итак, какой из них предпочтительнее printf или cout?
Вам действительно нужно заботиться о том, что имеет более быструю скорость выполнения? Они оба используются просто для печати текста на консоли /stdout, что обычно не является задачей, требующей сверхвысокого уровня эффективности. В этом отношении я бы не подумал, что в любом случае будет большая разница в скорости (хотя можно ожидать, что printf будет немного быстрее, потому что ему не хватает незначительных осложнений объектно-ориентированности). Тем не менее, учитывая, что мы имеем дело с операциями ввода-вывода, даже незначительная разница, вероятно, будет зависеть от накладных расходов ввода-вывода. Конечно, если вы сравнили эквивалентные методы для записи в файлы, это будет так.
printf - это просто стандартный способ вывода текста в stdout в C.
'cout' piping - это просто стандартный способ вывода текста в stdout на С++.
Говоря все это, в группе comp.lang.cc есть нить, обсуждающая ту же проблему. Однако консенсус, похоже, заключается в том, что вы должны выбирать один за другим по причинам, отличным от производительности.
У каждого есть свои накладные расходы. В зависимости от того, что вы печатаете, может быть и быстрее.
Вот два момента, которые приходят на ум -
printf() должен разбирать строку "format" и действовать на нее, что добавляет стоимость.
cout имеет более сложную иерархию наследования и передает объекты.
На практике разница не должна иметь значения для всех, кроме самых странных случаев. Если вы считаете, что это действительно важно - измерьте!
РЕДАКТИРОВАТЬ -
О, черт возьми, я не считаю, что я это делаю, но для записи, на моем очень конкретном тестовом примере, с моей самой конкретной машиной и ее очень специфической нагрузкой, компиляция в Release с использованием MSVC -
Печать 150 000 "Привет, мир!" s (без использования endl) занимает около -
90 мс для printf(), 79 мс для cout.
Печать 150 000 случайных удваивается -
3450 мс для printf(), 3420 мс для cout.
(усредненный за 10 прогонов).
Различия настолько тонкие, что это, вероятно, ничего не значит...
В Windows, по крайней мере, запись в консоль является огромным узким местом, поэтому "шумная" консольная программа будет намного медленнее, чем тихая. Таким образом, на этой платформе небольшие различия в библиотечных функциях, используемых для решения этой проблемы, вероятно, не будут иметь существенных различий на практике.
На других платформах это может быть иначе. Кроме того, это зависит от того, сколько вы выполняете консоль, по сравнению с другой полезной работой.
Наконец, это зависит от вашей реализации платформы библиотек ввода/вывода C и С++.
Таким образом, общий ответ на этот вопрос отсутствует.
Причиной С++ cout является медленная синхронизация по умолчанию с stdio.
Попробуйте выполнить следующее, чтобы отключить эту проблему.
ios_base::sync_with_stdio(false)
http://www.cplusplus.com/reference/iostream/ios_base/sync_with_stdio/
Производительность не является проблемой для сравнения; не может думать ни о чем, где он действительно рассчитывает (разработка консольной программы). Тем не менее, есть несколько моментов, которые вы должны учитывать:
Iostreams использует цепочку операторов вместо va_args. Это означает, что ваша программа не может сбой, потому что вы передали неправильное количество аргументов. Это может произойти с printf.
Iostreams использует перегрузку оператора вместо va_args - это означает, что ваша программа не может сбой, потому что вы передали int и ожидали строку. Это может произойти с printf.
У Iostreams нет встроенной поддержки форматированных строк (что является основной основной причиной # 1 и # 2). Это вообще хорошо, но иногда они полезны. Библиотека формата Boost привносит эту функцию в Iostreams для тех, кто нуждается в ней с определенным поведением (генерирует исключение), а не с undefined (как в случае с printf). Это в настоящее время выходит за рамки стандарта.
Iostreams, в отличие от equiquants от printf, могут обрабатывать буферы переменной длины непосредственно сами по себе, вместо того, чтобы вы были вынуждены иметь дело с жестко запрограммированным рывком.
Перейдите к cout.
Другой вопрос рассматривал относительную скорость форматированного ввода-вывода C-style и С++ iostreams:
Обратите внимание, однако, что обсуждаемые тесты были для форматирования в буферах памяти. Я предполагаю, что если вы на самом деле выполняете ввод-вывод в консоль или файл, то относительная разница в скорости будет намного меньше из-за ввода/вывода, занимающего больше времени.
В практическом плане я всегда находил printf быстрее, чем cout. Но опять же, cout делает намного больше для вас с точки зрения безопасности типов. Также помните, что printf является простой функцией, тогда как cout - это объект, основанный на сложной иерархии потоков, поэтому не очень справедливо сравнивать время выполнения.
Если вы используете С++, вы должны использовать cout, а printf принадлежит семейству C-функций. Есть много улучшений, сделанных для cout, от которых вы можете воспользоваться. Что касается скорости, это не проблема, так как консольный ввод-вывод в любом случае будет медленным.
Чтобы решить эту проблему:
#include <iostream>
#include <cstdio>
#include <ctime>
using namespace std;
int main( int argc, char * argcv[] ) {
const char * const s1 = "some text";
const char * const s2 = "some more text";
int x = 1, y = 2, z = 3;
const int BIG = 2000;
time_t now = time(0);
for ( int i = 0; i < BIG; i++ ) {
if ( argc == 1 ) {
cout << i << s1 << s2 << x << y << z << "\n";
}
else {
printf( "%d%s%s%d%d%d\n", i, s1, s2, x, y, z );
}
}
cout << (argc == 1 ? "cout " : "printf " ) << time(0) - now << endl;
}
создает одинаковые тайминги для cout и printf.
Если вам когда-либо понадобится выяснить причины производительности, что-то еще в корне неправильно с вашим приложением - рассмотрите возможность использования какого-либо другого средства ведения журнала или пользовательского интерфейса;)
Недавно я работал над консольным приложением С++ в окнах, которые копировали файлы с помощью CopyFileEx и повторяли пути "to" и "from" к консоли для каждой копии, а затем отображали среднюю пропускную способность в конце операции.
Когда я запускал консольное приложение с помощью printf, чтобы вывести строки, которые я получал 4 Мб/с, при замене printf на std:: cout пропускная способность упала до 800 кб/сек.
Мне было интересно, почему вызов std:: cout был намного дороже и даже зашел так далеко, чтобы отобразить одну и ту же строку на каждой копии, чтобы получить лучшее сравнение по вызовам. Я сделал несколько прогонов, чтобы выровнять сравнение, но разница в 4 раза сохранялась.
Затем я нашел этот ответ на stackoverflow..
Включение буферизации для stdout сделало трюк, теперь мои номера пропускной способности для printf и std:: cout почти одинаковы.
Я не углублялся в то, как printf и cout отличаются в буферизации вывода консоли, но установка выходного буфера, прежде чем я начну писать на консоль, решила мою проблему.
Под капотом они будут использовать один и тот же код, поэтому разницы скорости не будут иметь значения.
Если вы работаете только с Windows, нестандартный cprintf() может быть быстрее, поскольку он обходит много потоков.
Однако это нечетное требование. Никто не может так быстро прочесть. Почему бы не записать вывод в файл, тогда пользователь может просматривать файл на досуге?
Почему бы вам не провести эксперимент? В среднем для меня печатаем струнного helloperson;\n, используя printf, в среднем, 2 такта, в то время как cout с использованием endl занимает огромное количество времени - 1248996720685 тактов. Использование cout с "\n", поскольку новая строка занимает всего 41981 тактов. Короткий URL для моего кода ниже:
cpp.sh/94qoj
Возможно, срок действия ссылкиистек.
Чтобы ответить на ваш вопрос, printf быстрее.
#include <iostream>
#include <string>
#include <ctime>
#include <stdio.h>
using namespace std;
int main()
{
clock_t one;
clock_t two;
clock_t averagePrintf;
clock_t averageCout;
clock_t averagedumbHybrid;
for (int j = 0; j < 100; j++) {
one = clock();
for (int d = 0; d < 20; d++) {
printf("helloperson;");
printf("\n");
}
two = clock();
averagePrintf += two-one;
one = clock();
for (int d = 0; d < 20; d++) {
cout << "helloperson;";
cout << endl;
}
two = clock();
averageCout += two-one;
one = clock();
for (int d = 0; d < 20; d++) {
cout << "helloperson;";
cout << "\n";
}
two = clock();
averagedumbHybrid += two-one;
}
averagePrintf /= 100;
averageCout /= 100;
averagedumbHybrid /= 100;
cout << "printf took " << averagePrintf << endl;
cout << "cout took " << averageCout << endl;
cout << "hybrid took " << averagedumbHybrid << endl;
}
Да, я использовал слово "тупой". Я сначала сделал это для себя, считая, что результаты были сумасшедшими, поэтому я искал его, и в итоге я отправил свой код.
Надеюсь, что это поможет, Ndrewffght
Анекдотические доказательства:
Я однажды разработал класс ведения журнала для использования операторов ostream - реализация была безумно медленной (для огромных объемов данных).
Я не анализировал это много, так что это могло бы быть вызвано неправильным использованием Ostream или просто из-за объема данных, записанных на диск. (Класс был отменен из-за проблем с производительностью, и на практике предпочтительным был стиль printf/fmtmsg.)
Я согласен с другими ответами, что в большинстве случаев это не имеет значения. Если выход действительно является проблемой, вы должны рассмотреть способы его избежать или задержать, так как фактические обновления дисплея обычно стоят дороже, чем правильно реализованная строковая сборка. Тысячи линий, прокручивающихся за миллисекунды, в любом случае не очень информативны.
Вам нужно никогда задавать этот вопрос, так как пользователь сможет читать только медленнее, чем обоим.
Если вам нужно быстрое выполнение, не используйте также.
Как упоминалось выше, используйте какой-то журнал, если вам нужна запись об операциях.