Calcul des formules avec C++

Ajout de formules et calcul de résultats

Aspose.Cells dispose d’un moteur de calcul de formules intégré. Il peut non seulement recalculer les formules importées à partir de modèles de conception, mais également supporter le calcul des résultats des formules ajoutées en temps réel.

Aspose.Cells supporte la plupart des formules ou fonctions qui font partie de Microsoft Excel (Consultez la liste des fonctions supportées par le moteur de calcul). Ces fonctions peuvent être utilisées via les API ou dans les feuilles de conception. Aspose.Cells supporte un ensemble énorme de formules mathématiques, de chaînes, booléennes, de date/heure, statistiques, base de données, recherche, et de référence.

Utilisez la propriété GetFormula ou les méthodes SetFormula(…) de la classe Cell pour ajouter une formule à une cellule. Lors de l’application d’une formule, commencez toujours la chaîne par un signe égal (=), comme lors de la création d’une formule dans Microsoft Excel, et utilisez une virgule (,) pour délimiter les paramètres des fonctions.

Pour calculer les résultats des formules, l’utilisateur peut appeler la méthode CalculateFormula de la classe Workbook, qui traite toutes les formules intégrées dans un fichier Excel. Ou, il peut appeler la méthode CalculateFormula de la classe Worksheet, qui traite toutes les formules intégrées dans une feuille. Ou, l’utilisateur peut également appeler la méthode Calculate de la classe Cell, qui traite la formule d’une seule cellule :

#include <iostream>
#include "Aspose.Cells.h"
using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source directory path
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");

    // Output directory path
    U16String outDir(u"..\\Data\\02_OutputDirectory\\");

    // Create a new workbook
    Workbook workbook;

    // Add a new worksheet to the workbook
    int sheetIndex = workbook.GetWorksheets().Add();

    // Get the reference of the newly added worksheet
    Worksheet worksheet = workbook.GetWorksheets().Get(sheetIndex);

    // Add values to cells
    worksheet.GetCells().Get(u"A1").PutValue(1);
    worksheet.GetCells().Get(u"A2").PutValue(2);
    worksheet.GetCells().Get(u"A3").PutValue(3);

    // Add a SUM formula to cell A4
    worksheet.GetCells().Get(u"A4").SetFormula(u"=SUM(A1:A3)");

    // Calculate the results of formulas
    workbook.CalculateFormula();

    // Get the calculated value of cell A4
    U16String value = worksheet.GetCells().Get(u"A4").GetStringValue();

    // Save the Excel file
    workbook.Save(outDir + u"output.xls");

    std::cout << "Excel file saved successfully!" << std::endl;

    Aspose::Cells::Cleanup();
}

Important à savoir pour les formules

La propriété GetFormula et les méthodes SetFormula(…) de la classe Cell fonctionnent différemment des méthodes Calculate des classes Workbook, Worksheet, et Cell. La propriété GetFormula et les méthodes SetFormula(…) ajoutent simplement la formule à une cellule mais ne calculent pas le résultat à l’exécution. Pour obtenir le résultat des formules, veuillez appeler les méthodes Calculate.

Calcul direct de formule

Aspose.Cells possède un moteur de calcul de formules intégré. En plus de calculer les formules importées à partir d’un fichier, Aspose.Cells peut calculer les résultats des formules directement.

Parfois, vous souhaitez calculer directement les résultats des formules sans les ajouter dans une feuille de calcul. Les valeurs des cellules utilisées dans la formule existent déjà dans une feuille, et tout ce que vous avez à faire est de trouver le résultat de ces valeurs en utilisant une formule Microsoft Excel sans ajouter la formule dans une feuille.

Vous pouvez utiliser les API du moteur de calcul de formules d’Aspose.Cells pour Worksheet à calculate pour obtenir les résultats de telles formules sans les ajouter dans la feuille :

#include <iostream>
#include "Aspose.Cells.h"

using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source directory path
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");

    // Output directory path
    U16String outDir(u"..\\Data\\02_OutputDirectory\\");

    // Create a workbook
    Workbook workbook;

    // Access first worksheet
    Worksheet worksheet = workbook.GetWorksheets().Get(0);

    // Put 20 in cell A1
    Cell cellA1 = worksheet.GetCells().Get(u"A1");
    cellA1.PutValue(20);

    // Put 30 in cell A2
    Cell cellA2 = worksheet.GetCells().Get(u"A2");
    cellA2.PutValue(30);

    // Calculate the Sum of A1 and A2
    Aspose::Cells::Object results = worksheet.CalculateFormula(u"=Sum(A1:A2)");

    // Print the output
    std::cout << "Value of A1: " << cellA1.GetStringValue().ToUtf8() << std::endl;
    std::cout << "Value of A2: " << cellA2.GetStringValue().ToUtf8() << std::endl;
    std::cout << "Result of Sum(A1:A2): " << results.ToString().ToUtf8() << std::endl;

    Aspose::Cells::Cleanup();
}

Le code ci-dessus produit la sortie suivante :

Value of A1: 20
Value of A2: 30
Result of Sum(A1:A2): 50.0

Comment calculer des formules de manière répétée

Lorsqu’il y a beaucoup de formules dans le classeur et que l’utilisateur doit les calculer à plusieurs reprises en modifiant uniquement une petite partie d’entre elles, il peut être utile pour la performance d’activer la chaîne de calcul des formules : FormulaSettings.GetEnableCalculationChain().

#include <iostream>
#include <chrono>
#include "Aspose.Cells.h"

using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source directory path
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");

    // Load the template workbook
    Workbook workbook(srcDir + u"book1.xls");

    // Print the time before formula calculation
    auto start = std::chrono::system_clock::now();
    std::time_t start_time = std::chrono::system_clock::to_time_t(start);
    std::cout << "Start time: " << std::ctime(&start_time);

    // Set the CreateCalcChain as true
    workbook.GetSettings().GetFormulaSettings().SetEnableCalculationChain(true);

    // Calculate the workbook formulas
    workbook.CalculateFormula();

    // Print the time after formula calculation
    auto end = std::chrono::system_clock::now();
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);
    std::cout << "End time: " << std::ctime(&end_time);

    // Change the value of one cell
    workbook.GetWorksheets().Get(0).GetCells().Get(u"A1").PutValue(u"newvalue");

    // Re-calculate those formulas which depend on cell A1
    workbook.CalculateFormula();

    Aspose::Cells::Cleanup();
    return 0;
}

Important à savoir

Par défaut, la chaîne de calcul est désactivée. La création de la chaîne demande également du temps supplémentaire, et la première fois que vous calculez des formules (Workbook.CalculateFormula(…)) peut consommer plus de temps processeur et de mémoire par rapport au calcul des formules sans chaîne. Si l’utilisateur n’a pas besoin de recalculer fréquemment, le comportement par défaut (calculer la formule directement sans créer de chaîne de calcul) est la meilleure option.

Sujets avancés

Gérer les données des fichiers Excel avec C++ Gérer les commentaires et notes avec C++