如何包含影响c ++中的执行时间？

Question

I was hoping to get some sort of clarification regarding the run time of my MSVS2015 community solution.

I've basically made quite a simple application that uses libcurl to get historical data from a CSV file from yahoo finance. The data is from 2010 to 2016, dumped into a csv file in the solution's folder.

The reason I'm raising this question is because since I changed the solution from just using a single .cpp executing everything to making new .cpp files to basically make the code more maintainable the run time went from >1 second to about 3 seconds. This is my first time working with multiple .cpp and .h files, so I have very limited experience with how including them could affect the run-time.

To iterate on the issue; it is actually working fine - I just wish to understand how the run time can be so much longer when making such easy changes.

Here is the code:

historical.cpp

#include "stdafx.h"
#include "historical.h"


using namespace std;

static size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}


historical::historical(string symbol) {
    _mQueryString = "http://ichart.yahoo.com/table.csv?s=" + symbol + "&a=00&b=01&c=2010&d=01&e=01&f=2016&d=m&ignore=.csv"; // setup the query by adding the string param. (2010-2016).

    CURL *curl; // initialize cURL
    CURLcode res; // setup a response

    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, _mQueryString);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &_mHistorical);
        res = curl_easy_perform(curl);
        curl_easy_cleanup(curl);


        string* pBuffer = &_mHistorical;
    }
}

string* historical::getHistorical() {
    return &_mHistorical;
}
historical::~historical() {
    cout << "The object is deleted";
} 

historical.h

#pragma once

//======================
//include guard
#ifndef  __HISTORICAL_H_INCLUDED__
#define __HISTORICAL_H_INCLUDED__

//======================
// forward declared dependencies

//======================
// included dependencies::
#include <iostream>
#include <fstream>
#include <stdio.h> 
#include <curl/curl.h> 
#include <string>

//======================
// historical::

using namespace std;
class historical {
public:
    historical(string symbol);
    string* getHistorical();
    ~historical();
private:
    string _mHistorical;
    string _mQueryString;
};


#endif

geostocks.cpp (including main())

// geostocks.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <stdio.h> 
#include <curl/curl.h> 
#include <string>
#include "historical.h"
using namespace std;

void writer(string* pInput);

static size_t WriteCallback(void *contents, size_t size, size_t nmemb, void *userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}



int main(void)
{
    historical his("AAPL");
    string output;

    output = *his.getHistorical();
    writer(&output);

    return 0;
}

void writer(string* pInput) {
    ofstream mf("test.csv");
    if (mf.is_open()) {
        mf << *pInput;
        mf.close();
    }
    else cout << "Unable to open file" << endl;
}

Answer 1

Not in any way at all.

Your observations are far more likely to be due to the network HTTP request, wouldn't you say?

Answer 2

When you include a file, .cpp or .h, the contents of the file are simply copied into the including file in preparation for the compilation phase.

Preprocessor directives are basically text-based operations that should not affect the execution speed of the program.

As you have mentioned, separating code into implementation and interface files helps with code maintainability.

Answer 3

拆分/组织代码的方式不会影响可执行文件的运行时间。