Как получить точное количество раз, когда функция выполняется на С++?

Ответ 1

Я надеюсь, что следующий фрагмент кода решит вашу проблему!

#include<iostream.h>

void callMe()
{
    static int count=0;
    cout << "I am called " << ++count << " times!\n";
}

int main()
{
    callMe();
    callMe();
    callMe();
    callMe();
    return 0;
}

Здесь статическая переменная сохранит свое значение и будет печатать счетчик, увеличивающийся каждый раз!

Ответ 2

void callMe()
{
    static int count = 0; // note 'static' keyword
    cout<<"I am called "<<++count<<" times!\n";
}

Ответ 3

сделать статическую переменную

поэтому определите его в самой функции и из-за свойства static она сохранит его значение в каждом вызове.

void callMe()
{
    static int count=0;
    cout<<"I am called "<<++count<<" times!\n";
}

статическое хранилище выполняется в сегменте данных, а не в стеке функций, поэтому в каждой функции вызова принимается модифицированное значение. Таким образом, он напечатает желаемый результат.

но count, который вы указали, является локальным и имеет хранилище в стеке, поэтому для каждого вызова функции всегда требуется count = 0

Ответ 4

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, все изменения указывают на то же место в памяти. Если у вас нет веских оснований не следовать этому, я бы сказал, используйте это.

Надеюсь, я больше не смутил вас, Счастливая охота.

Ответ 5

Вам нужно будет передать его в качестве аргумента или сохранить его как состояние функции.

int count = 0;
auto callMe = [=] mutable {
    cout<<"I am called "<<++count<<" times!\n";
};

Ответ 6

Если вы хотите подсчитать количество вызовов одной функции, вы действительно можете использовать переменную счетчика 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.

Ответ 7

Вы должны использовать ключевое слово "статическое" до подсчета.

Исправленный фрагмент кода будет выглядеть примерно так: *

void callMe()
{
    static int count;
    cout<<"I am called "<<++count<<" times!\n";
}

Ответ 8

Вы можете передавать счетчик переменных по ссылке и увеличивать его каждый раз, когда функция вызывается следующим образом:

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;
  }

Для получения дополнительной информации о передаче по ссылке вы можете обратиться здесь.

Ответ 9

По существу, все здесь предлагают. Это макрос, который я использовал время от времени. Я считаю, что это упрощает чтение.

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();
}