Assignment; Speed Test of for() loop vs std::for_each()

[tmason]

Hello,

For a class assignment, I was asked to create a program comparing the speed of a for() loop versus a std::for_each() loop.

Below is what I came up with; it compiles and runs but is this a proper test?

Based on what I have a for_each loop is much faster but I am not sure if what I have is a correct test.

Thank you for your time:

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <ctime>

class SimpleObject {

private:

	int IntToIterate;
	float FloatToIterate;

protected:

public:

	SimpleObject();
	~SimpleObject();

	int GetInt();
	float GetFloat();

	void IterateInt();
	void IterateFloat();

};

SimpleObject::SimpleObject() {

	IntToIterate = 0;
	FloatToIterate = 0.0f;

}

SimpleObject::~SimpleObject() {



}

int SimpleObject::GetInt() {

	return IntToIterate;

}

float SimpleObject::GetFloat() {

	return FloatToIterate;

}

void SimpleObject::IterateInt() {

	IntToIterate += 1;

}

void SimpleObject::IterateFloat() {

	FloatToIterate += 1.0f;

}

std::string promptUser() {

	std::string Input;

	std::cout << "\nType in the number of iterations you wish the program to go through for testing. \n\nType in 'exit' or '0' to exit the program: ";

	while (std::getline(std::cin, Input)) {

		if (Input == "0" || Input == "exit") {

			exit(EXIT_SUCCESS);

		}
		else {

			return Input;

		}

	}

}

int main(int argc, char** argv) {
	
	while (true) {

		std::stringstream Converter(promptUser());

		int NumberOfIterations = 0;

		if (Converter >> NumberOfIterations) {

			std::cout << "\n\nWe will be performing " << NumberOfIterations << " iterations.";

			std::vector<SimpleObject> VectorOfSimpleObjects(NumberOfIterations);

			std::cout << "\n\n" << NumberOfIterations << " SimpleObjects created!";

			std::cout << "\n\nBeginning iteration of " << NumberOfIterations << " SimpleObjects by going over them " << NumberOfIterations << " times.";

			std::cout << "\n\nFirst, using old for() method.";

			clock_t begin = clock();

			for (int i = 0; i < NumberOfIterations; ++i) {

				VectorOfSimpleObjects[i].IterateFloat();
				VectorOfSimpleObjects[i].IterateInt();

			}

			clock_t end = clock();

			clock_t elapsed = end - begin;

			float Seconds = ((float)elapsed) / CLOCKS_PER_SEC;

			std::cout << "\n\nOld method took " << Seconds << " seconds in elapsed time.";

			std::cout << "\n\nNow, the new for_each method.";

			begin = clock();

			std::for_each(VectorOfSimpleObjects.begin(), VectorOfSimpleObjects.end(), [](SimpleObject& MainObject){ MainObject.IterateFloat(); });
			std::for_each(VectorOfSimpleObjects.begin(), VectorOfSimpleObjects.end(), [](SimpleObject& MainObject){ MainObject.IterateInt(); });

			end = clock();

			elapsed = end - begin;

			Seconds = ((float)elapsed) / CLOCKS_PER_SEC;

			std::cout << "\n\nNew method took " << Seconds << " seconds in elapsed time.";

		}

	}
	
}

[cire]

I think I would rather go with something like:

(Renamed some of the methods/data members to be less cumbersome and actually reflect what they're doing - increment as opposed to iterate.)

// http://ideone.com/NXfPh5
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <ctime>

class SimpleObject 
{
    int _int;
    float _float;

public:
    SimpleObject() : _int(0), _float(0.0f) {}

    int GetInt() { return _int; }
    float GetFloat() { return _float; }

    void incrementInt() { ++_int; }
    void incrementFloat() { _float += 1.0f; }
};

std::size_t getCount(const std::string& prompt)
{
    std::string Input;

    std::cout << prompt << "\n> ";

    std::getline(std::cin, Input);

    if (Input == "exit")
        return 0;

    return std::stoi(Input);
}

void doForLoop(std::vector<SimpleObject>& v, std::size_t iterations)
{
    for (std::size_t i = 0; i < iterations; ++i)
    {
        for (auto it = v.begin(); it != v.end(); ++it)
        {
            it->incrementFloat();
            it->incrementInt();
        }
    }
}

void doForEach(std::vector<SimpleObject>& v, std::size_t iterations)
{
    for (std::size_t i = 0; i < iterations; ++i)
        for_each(v.begin(), v.end(), [](SimpleObject& o) { o.incrementFloat(); o.incrementInt(); });
}

void doRangedFor(std::vector<SimpleObject>& v, std::size_t iterations)
{
    for (std::size_t i = 0; i < iterations; ++i)
        for (auto & e : v)
            e.incrementFloat(), e.incrementInt();
}

using func_type = void(*)(std::vector<SimpleObject>&, std::size_t);
void test(const std::string& testName, func_type testme, std::size_t iterations, std::size_t objects)
{
    std::vector<SimpleObject> v(objects);

    clock_t begin = clock();
    testme(v, iterations);
    clock_t end = clock();

    std::cout << "Test \"" << testName << "\" took " << (float(end) - begin) / CLOCKS_PER_SEC << " seconds.\n";
}


int main(int argc, char** argv) 
{
    std::size_t nIterations;
    std::size_t nObjects;

    do 
    {
        nIterations = getCount("Enter the number of iterations:");
        nObjects = getCount("Enter the number of objects in the container:");

        if (nIterations && nObjects)
        {
            std::cout << "\n\nWe will be performing " << nIterations << " iterations on a container holding ";
            std::cout << nObjects << " objects.\n";

            test("for loop", doForLoop, nIterations, nObjects);
            test("for each", doForEach, nIterations, nObjects);
            test("ranged for", doRangedFor, nIterations, nObjects);
        }
    } while (nIterations && nObjects);
}

Remember to make sure you're compiling with optimizations on!

[tmason]

@cire your code is awesome; half the size, more functional, and a better test.

Thank you.

I'll get at your level someday :) :)