Analyzing your prompt, please hold on...
An error occurred while retrieving the results. Please refresh the page and try again.
Range.Transpose() e funziona su ogni versione di Excel, mentre il secondo utilizza Cell.SetDynamicArrayFormula() per scrivere una moderna formula =TRANSPOSE(...) come array dinamico che si espande automaticamente in Excel 365 o Excel 2021. Il terzo approccio utilizza Cell.SetArrayFormula() per scrivere una classica formula matrice Ctrl+Shift+Enter (CSE) compatibile con le versioni precedenti di Excel. Questo articolo illustra ciascun approccio con istruzioni passo-passo ed esempi di codice completi.
Trasporre un intervallo significa ruotarlo in modo che ciò che era una riga diventi una colonna e ciò che era una colonna diventi una riga, riflettendo efficacemente i dati lungo la diagonale principale. In Microsoft Excel, la funzione del foglio di lavoro TRANSPOSE esegue questa operazione, e il riferimento concettuale è documentato all’indirizzo https://support.microsoft.com/en-us/excel/functions/transpose-function. Questo concetto può essere applicato a livello di programmazione a un intervallo di celle, il che è utile in molti scenari aziendali e di reportistica.
| Region | Europe | Asia | North America |
|---|---|---|---|
| Qtr 1 | 21704714 | 8774099 | 12094215 |
| Qtr 2 | 17987034 | 12214447 | 10873099 |
| Qtr 3 | 19485029 | 14356879 | 15689543 |
| Qtr 4 | 22567894 | 15763492 | 17456723 |
| L’articolo presenta quindi tre diversi modi per trasporre questi dati utilizzando Aspose.Cells for C++, ciascuno adatto a una diversa versione di Excel e a un diverso caso d’uso. |
Utilizzare questo approccio ogni volta che si desidera trasporre i dati senza coinvolgere la funzione del foglio di lavoro TRANSPOSE. Funziona su ogni versione di Excel e non dipende dagli array dinamici, il che lo rende l’opzione più sicura e compatibile tra le versioni. È ideale quando si ha bisogno solo del risultato trasposto finale e non si desidera mantenere la formula TRANSPOSE originale nella cartella di lavoro.
Range.Transpose() è un metodo di istanza della classe Aspose.Cells.Range. Chiamandolo, l’intervallo viene capovolto in place scambiando righe e colonne, quindi ciò che era una riga diventa una colonna e ciò che era una colonna diventa una riga. Il metodo modifica direttamente le celle sottostanti senza scrivere alcuna formula.
LoadOptions impostato sul formato .xlsx creando un Workbook(srcFile, LoadOptions(LoadFormat::Xlsx)).workbook.GetWorksheets().Get(0).worksheet.GetCells().cells.CreateRange(u"A1:D5").source.Transpose() per ruotare l’intervallo in place, scambiando righe e colonne.workbook.Save(outputFile).#include "Aspose.Cells.h"
using namespace Aspose::Cells;
int main() {
Aspose::Cells::Startup();
U16String srcFile(u"source.xlsx");
U16String outputFile(u"transposed.xlsx");
LoadOptions loadOptions(LoadFormat::Xlsx);
Workbook workbook(srcFile, loadOptions);
Worksheet worksheet = workbook.GetWorksheets().Get(0);
Cells cells = worksheet.GetCells();
Range source = cells.CreateRange(u"A1:D5");
source.Transpose();
workbook.Save(outputFile);
Aspose::Cells::Cleanup();
return 0;
}
Utilizzare questo approccio quando si desidera preservare la formula =TRANSPOSE(A1:D5) come formula attiva nella cartella di lavoro di output, in modo che il risultato si aggiorni automaticamente se i dati di origine cambiano, e il file Excel di destinazione verrà aperto in Excel 365 / Excel 2021 o versioni successive dove gli array dinamici e l’operatore di spill sono supportati.
Cell.SetDynamicArrayFormula(const char* formula, FormulaParseOptions options, bool calculateValue) è un metodo di Aspose.Cells.Cell che imposta la formula della cella come una formula di array dinamico. Excel valuta la formula una volta ed espande automaticamente il risultato nelle celle circostanti. Il terzo parametro, quando impostato su true, indica ad Aspose.Cells di calcolare anche i valori risultanti al momento della scrittura.
Workbook(srcFile, LoadOptions(LoadFormat::Xlsx)).workbook.GetWorksheets().Get(0) e accedere alla sua raccolta Cells tramite worksheet.GetCells().cells.Get(u"A6").SetDynamicArrayFormula(u"=TRANSPOSE(A1:D5)", nullptr, true).nullptr passa i FormulaParseOptions predefiniti e il terzo argomento true indica ad Aspose.Cells di trattare la formula come array dinamico e di valutarla in modo che i valori espansi vengano scritti nella cartella di lavoro.workbook.Save(outputFile).
La cella A6 contiene la formula =TRANSPOSE(A1:D5) ed Excel espande automaticamente il risultato nella regione A6:D10, un blocco di 5 righe per 4 colonne pari ai dati trasposti.#include "Aspose.Cells.h"
#include <string>
using namespace Aspose::Cells;
int main() {
Aspose::Cells::Startup();
std::string srcFile = "source.xlsx";
std::string outFile = "output_transpose_dynamic.xlsx";
LoadOptions loadOptions(LoadFormat::Xlsx);
Workbook workbook(U16String(srcFile.c_str()), loadOptions);
Worksheet worksheet = workbook.GetWorksheets().Get(0);
Cells cells = worksheet.GetCells();
Cell cell = cells.Get(u"A6");
FormulaParseOptions options;
cell.SetDynamicArrayFormula(U16String("=TRANSPOSE(A1:D5)"), options, true);
workbook.Save(U16String(outFile.c_str()), SaveFormat::Xlsx);
Aspose::Cells::Cleanup();
return 0;
}
Utilizzare questo approccio quando si desidera preservare una formula TRANSPOSE nella cartella di lavoro, ma il file Excel di destinazione potrebbe essere aperto in versioni precedenti di Excel (pre-2021, incluse 2019, 2016, 2013 e così via) dove l’espansione degli array dinamici non è supportata. La classica formula matrice CSE (Ctrl+Shift+Enter) è l’alternativa compatibile con le versioni legacy che tutte le versioni di Excel possono valutare.
Cell.SetArrayFormula(const char* arrayFormula, int nRows, int nColumns) è un metodo di Aspose.Cells.Cell che assegna una formula matrice (CSE) classica alla cella di ancoraggio e dichiara le dimensioni dell’array risultante. Aspose.Cells scrive il marcatore di formula matrice multi-cella in modo che Excel valuti la formula come una singola espressione di array che riempie l’intervallo dichiarato.
Workbook(srcFile, LoadOptions(LoadFormat::Xlsx)).workbook.GetWorksheets().Get(0) e accedere alla sua raccolta Cells tramite worksheet.GetCells().cells.Get(u"A6").SetArrayFormula(u"=TRANSPOSE(A1:D5)", 4, 5). Il secondo argomento 4 è il numero di righe dell’array di destinazione e il terzo argomento 5 è il numero di colonne.workbook.Save(outputFile).
La cella A6 è l’ancoraggio della formula matrice e l’array valutato si estende per 4 righe per 5 colonne a partire da A6, corrispondendo alle dimensioni trasposte dell’origine A1:D5. Excel scrive un singolo marcatore di formula matrice attraverso l’intervallo risultante in modo che le versioni precedenti di Excel lo valutino correttamente.TRANSPOSE e questo approccio è universalmente compatibile tra tutte le versioni di Excel.
#include "Aspose.Cells.h"
#include <string>
using namespace Aspose::Cells;
int main() {
Aspose::Cells::Startup();
// Carica la cartella di lavoro sorgente con LoadOptions xlsx
std::string srcFile = "source.xlsx";
Workbook workbook(U16String(srcFile.c_str()), LoadOptions(LoadFormat::Xlsx));
// Accedi al primo foglio di lavoro e alla sua collezione Cells
Worksheet worksheet = workbook.GetWorksheets().Get(0);
Cells cells = worksheet.GetCells();
// Imposta la classica formula in array CSE sulla cella A6.
// La formula =TRANSPOSE(A1:D5) ruota l'intervallo sorgente di 5 righe x 4 colonne
// in un array di 4 righe x 5 colonne. Il secondo argomento (4) è il numero di righe
// e il terzo argomento (5) è il numero di colonne dell'array risultante.
// Aspose.Cells scrive il marcatore di formula in array CSE così Excel la valuta come
// una singola formula in array multi-cella, compatibile con le versioni meno recenti
// di Excel (2019, 2016, 2013, ecc.) che non supportano lo spilling dinamico degli array.
cells.Get(u"A6").SetArrayFormula(u"=TRANSPOSE(A1:D5)", 4, 5);
// Salva la cartella di lavoro così che il marcatore della formula in array venga persistito
workbook.Save(u"output.xlsx");
Aspose::Cells::Cleanup();
return 0;
}
| Approccio | API / Metodo | Versione di Excel | Formula di origine preservata? | Intervallo di output |
|---|---|---|---|---|
| Approccio 1 — Trasposizione in place | Range.Transpose() |
Tutte le versioni di Excel | No (solo valori) | Intervallo di ancoraggio iniziale, 5×4 |
| Approccio 2 — Formula array dinamico | Cell.SetDynamicArrayFormula |
Excel 365 / 2021+ | Sì (si espande dinamicamente) | Espanso dall’ancoraggio |
| Approccio 3 — Formula matrice classica (CSE) | Cell.SetArrayFormula |
Tutte le versioni di Excel | Sì (formula matrice multi-cella) | Dimensione esplicita, 4×5 |
| Utilizzare l'Approccio 1 quando serve una trasformazione rapida e compatibile tra versioni e si desidera solo che i valori trasposti vengano scritti nel file. Utilizzare l'Approccio 2 quando Excel moderno è garantito e si vuole che la formula rimanga attiva e si aggiorni se l’origine cambia. Utilizzare l'Approccio 3 quando serve la massima compatibilità con una formula preservata attraverso ogni versione di Excel, comprese le versioni precedenti che non supportano gli array dinamici. |
Analyzing your prompt, please hold on...
An error occurred while retrieving the results. Please refresh the page and try again.