#include<iostream>
using namespace std;
void callMe()
{
int count=0;
cout<<"I am called "<<++count<<" times!\n";
}
int main()
{
callMe();
callMe();
callMe();
callMe();
return 0;
}
В этом случае вывод будет
I am called 1 times! I am called 1 times! I am called 1 times! I am called 1 times!
Вместо этого я хочу, чтобы результат печатался как
I am called 1 times! I am called 2 times! I am called 3 times! I am called 4 times!
Я надеюсь, что следующий фрагмент кода решит вашу проблему!
#include<iostream.h>
void callMe()
{
static int count=0;
cout << "I am called " << ++count << " times!\n";
}
int main()
{
callMe();
callMe();
callMe();
callMe();
return 0;
}
Здесь статическая переменная сохранит свое значение и будет печатать счетчик, увеличивающийся каждый раз!
void callMe()
{
static int count = 0; // note 'static' keyword
cout<<"I am called "<<++count<<" times!\n";
}
сделать статическую переменную
поэтому определите его в самой функции и из-за свойства static она сохранит его значение в каждом вызове.
void callMe()
{
static int count=0;
cout<<"I am called "<<++count<<" times!\n";
}
статическое хранилище выполняется в сегменте данных, а не в стеке функций, поэтому в каждой функции вызова принимается модифицированное значение. Таким образом, он напечатает желаемый результат.
но count, который вы указали, является локальным и имеет хранилище в стеке, поэтому для каждого вызова функции всегда требуется count = 0
3 пути, 2 из них уже упомянуты здесь. Я бы обобщил и объяснил причины:
1) Объявите переменную как статическую:
void callMe()
{
static int count=0;
cout<<"I am called "<<++count<<" times!\n";
}
Это работает, потому что в памяти теперь создается единственная копия счетчика, а не создается каждый раз, когда вызывается функция, а затем удаляется, когда функция выполняется. Также стоит отметить, что счетчик по-прежнему является локальным для функции, то есть если вы попытаетесь сделать что-то вроде этого:
int main()
{
int count;
callMe();
callMe();
callMe();
callMe();
cout<<"you called "<<count<<"functions!\n";
return 0;
}
count по-прежнему будет отображать значение мусора, потому что счетчик для вашей функции и подсчет для вашего основного - это две разные переменные в двух разных местах.
2) Настройте глобальную переменную:
int count=0;
void callMe()
{
cout<<"I am called "<<++count<<" times!\n";
}
В приведенном выше примере переменная имеет глобальную область, поэтому вся программа использует одну копию переменной, и, следовательно, внесенные изменения будут отражаться повсюду в программе. Вы можете использовать этот подход, если вам нужно контролировать более двух функций. например:
int count=0;
void callMe()
{
cout<<"I am called "<<++count<<" times!\n";
}
void callMe2()
{
cout<<"I am called 2 "<<++count<<" times!\n";
}
int main()
{
callMe();
callMe();
callMe2();
callMe2();
cout<<"you called "<<count<<" functions!\n";
return 0;
}
Так как счет здесь в основном распространен как для функций, так и для основной, все они относятся к одному и тому же значению, а не к созданию собственных локальных копий. Может быть перепутано, если у вас есть переменные с одинаковым именем. Чтобы понять разницу между глобальной и статической переменной и их масштабом, нажмите здесь
3) Передайте ссылку переменной:
void callMe(int &count)
{
cout<<"I am called "<<count++<<" times!\n";
}
void callMe2(int &count)
{
cout<<"I am called 2 "<<++count<<" times!\n";
}
int main()
{
int count=0;
callMe(count);
callMe(count);
callMe2(count);
callMe2(count);
cout<<"you called "<<count<<" functions!\n";
return 0;
}
Это, пожалуй, самый чистый способ сделать это, переменная локальна для основного (что позволит сэкономить вам сложности сбора мусора), и поскольку это пропуск по refrence, все изменения указывают на то же место в памяти. Если у вас нет веских оснований не следовать этому, я бы сказал, используйте это.
Надеюсь, я больше не смутил вас, Счастливая охота.
Вам нужно будет передать его в качестве аргумента или сохранить его как состояние функции.
int count = 0;
auto callMe = [=] mutable {
cout<<"I am called "<<++count<<" times!\n";
};
Если вы хотите подсчитать количество вызовов одной функции, вы действительно можете использовать переменную счетчика static.
В качестве альтернативы, если вы хотите сделать это для отладки, это не худшая идея использовать для этого инструмент профилирования. Например Valgrind Callgrind [акцент мой]:
Callgrind - это инструмент профилирования, который записывает историю вызовов среди функций в программе, выполняемой как граф вызовов. По умолчанию собранные данные состоят из количества выполненных команд, их связи с исходными строками, отношения вызывающего/вызываемого между функциями и номеров таких вызовов.
Когда вы используете gcc, вы также можете возиться с макросом __PRETTY_FUNCTION__ и глобальной картой:
#include <iostream>
#include <string>
#include <map>
std::map<std::string, int> call_counts;
void call_me_one() {
call_counts[__PRETTY_FUNCTION__] += 1;
}
void call_me_two() {
call_counts[__PRETTY_FUNCTION__] += 1;
}
void call_me_three() {
call_counts[__PRETTY_FUNCTION__] += 1;
}
int main()
{
for (int i = 0; i < 10; i++)
call_me_one();
for (int i = 0; i < 20; i++)
call_me_two();
for (int i = 0; i < 30; i++)
call_me_three();
for (auto it = call_counts.begin(); it != call_counts.end(); ++it)
std::cout << (*it).first << " was being called "
<< (*it).second << " times.\n";
}
Здесь вывод на моей машине:
void call_me_one() was being called 10 times.
void call_me_three() was being called 30 times.
void call_me_two() was being called 20 times.
Вы должны использовать ключевое слово "статическое" до подсчета.
Исправленный фрагмент кода будет выглядеть примерно так: *
void callMe()
{
static int count;
cout<<"I am called "<<++count<<" times!\n";
}
Вы можете передавать счетчик переменных по ссылке и увеличивать его каждый раз, когда функция вызывается следующим образом:
void callMe(int &count)
{
cout<<"I am called "<<count++<<" times!\n";
}
int main()
{
int count=0;
callMe(count);
callMe(count);
callMe(count);
callMe(count);
return 0;
}
Для получения дополнительной информации о передаче по ссылке вы можете обратиться здесь.
По существу, все здесь предлагают. Это макрос, который я использовал время от времени. Я считаю, что это упрощает чтение.
in a separate header: (say debug_helper.h)
---------------------
#define COUNT_USAGE() {static int count=0;++count;std::cout<<"Called "<<count<<" times\n";}
In the CPP file:
----------------
#include "debug_helper.h"
void callMe()
{
COUNT_USAGE();
}