返回列表 發帖

707 動態記憶體配置

本帖最後由 鄭又綸 於 2024-10-26 10:46 編輯

1. 題目說明:
請依下列題意進行作答,使輸出值符合題意要求。

2. 設計說明:
請撰寫一程式,製作矩形面積計算機,讓使用者輸入一個正整數n,代表有n個矩形,接著依序輸入n個矩形的長、寬(皆為正整數),計算各個矩形的面積並由小而大輸出。

提示:若使用 Java 語言答題,請以「JP」開頭命名包含 main 靜態方法的 class,評測系統才能正確評分。

3. 輸入輸出:
輸入說明
一個正整數n及n個矩形的長、寬(皆為正整數)

輸出說明
由小而大的矩形面積計算結果

範例輸入1
3
8 3
9 4
5 5

範例輸出1
8x3=24
5x5=25
9x4=36


範例輸入2
5
5 5
10 5
5 20
7 3
4 6

範例輸出2
7x3=21
4x6=24
5x5=25
10x5=50
5x20=100


本帖隱藏的內容需要回復才可以瀏覽

,khjgfjhlkuhlk
(.)   (.)
    ..
  -----

TOP

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. int n;
  4. struct Data
  5. {
  6.     int a, b, c;
  7. };
  8. bool compare(Data d1, Data d2)
  9. {
  10.     return d2.c>d1.c;
  11. }
  12. int main()
  13. {
  14.     cin>>n;
  15.     Data d[n];
  16.     for(int i=0; i<n; i++)
  17.     {
  18.         cin>>d[i].a>>d[i].b;
  19.         d[i].c=d[i].a*d[i].b;
  20.     }
  21.     sort(d, d+n, compare);
  22.     for(int i=0; i<n; i++)
  23.         cout<<d[i].a<<'x'<<d[i].b<<'='<<d[i].c<<endl;
  24.     return 0;
  25. }
複製代碼

TOP

補充說明:struct 和比較函數
1. 什麼是 struct(結構)?
struct 是一種 把多個不同但相關的資料打包在一起 的方式。

想像一下,現在我們要處理每個矩形的資料,而每個矩形有三個重要資訊:長、寬、面積。我們可以用三個分開的陣列來記錄這些資料,但這樣有點麻煩,每個矩形的資訊就會分散在不同地方。

這時候,我們可以用 struct 把每個矩形的 長、寬 和 面積 一起打包在一個「盒子」裡,這樣資料會更有條理,而且對每個矩形的操作會變得更簡單。

struct 語法格式:
  1. struct 結構名稱 {
  2.     資料型別 成員名稱1;
  3.     資料型別 成員名稱2;
  4.     // ...其他成員
  5. };
複製代碼
這個語法的重點:

struct 是關鍵字,用來定義一個新的結構體。
結構名稱 是你給這個結構取的名字。這個名字可以隨便取,但最好能代表這個結構的用途。
成員名稱 是這個結構裡的變數,也就是我們要存放的資料。每個成員都要有自己的資料型別(例如 int 或 float)。

範例:
  1. struct Data {
  2.     int a;  // 紀錄矩形的長
  3.     int b;  // 紀錄矩形的寬
  4.     int c;  // 紀錄矩形的面積
  5. };
複製代碼
這個 struct 就像是一個自訂的「資料夾」,裡面有三個格子:一個用來放 長、一個用來放 寬,還有一個用來放 面積。所以我們可以很方便地使用這個結構來儲存每個矩形的資料。

使用 struct:
定義完 struct 之後,我們就可以像使用其他資料型別(例如 int 或 float)一樣來使用這個結構體。

假設我們要存放 5 個矩形的資料,我們可以宣告一個 Data 型別的陣列:
  1. Data d[5];  // 宣告一個存放 5 個矩形資料的陣列
複製代碼
接著,我們可以分別存取每個矩形的長、寬和面積:
  1. d[0].a = 8;  // 給第一個矩形設定長度為 8
  2. d[0].b = 3;  // 給第一個矩形設定寬度為 3
  3. d[0].c = d[0].a * d[0].b;  // 計算並存入第一個矩形的面積
複製代碼
這裡,d[0] 代表第一個矩形,透過 .a、.b、.c 來存取這個矩形的長、寬和面積。

使用 struct 的好處:
整齊:我們可以把每個矩形的所有資料都放在一起,不用分散在多個陣列裡。
容易操作:當我們要處理矩形時,我們只需要處理這個「盒子」(結構),不需要分別處理每個長、寬和面積。
例如:
  1. Data d[5];  // 宣告一個有 5 個矩形的陣列
  2. d[0].a = 8; // 給第一個矩形設定長度為 8
  3. d[0].b = 3; // 給第一個矩形設定寬度為 3
  4. d[0].c = d[0].a * d[0].b; // 計算第一個矩形的面積
複製代碼
這樣,我們就把第一個矩形的所有資料都存在 d[0] 裡,像是用「盒子」裝了這些資料。

2. 什麼是比較函數?
比較函數的作用是告訴程式該如何比較兩個矩形,然後進行排序。在我們的題目中,我們希望矩形的面積能夠 從小到大 排列。

為了實現這個目標,我們需要定義一個「規則」,這個規則告訴程式怎麼比較兩個矩形的面積。這就是比較函數的工作。

比較函數範例:
  1. bool compare(Data d1, Data d2) {
  2.     return d2.c > d1.c;
  3. }
複製代碼
compare(Data d1, Data d2) 這行的意思是:比較兩個矩形 d1 和 d2 的面積。
d2.c > d1.c 這一行表示如果第二個矩形的面積比第一個大,那麼我們就讓 d1 排在 d2 之前。因為 sort 函數會根據這個規則進行排序,這樣面積小的就會排在前面。
更簡單的解釋:
假設我們有兩個矩形,它們的面積分別是 24 和 36。

當我們比較時,如果 36 比 24 大,我們就說:「OK,24 應該排在 36 前面」。
這樣,當我們用這個規則一一比較所有矩形的面積,最後程式就會自動把它們按面積從小到大排列。

TOP

本帖最後由 徐啟祐 於 2024-9-7 18:06 編輯
  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. struct Data{
  4.     int len;
  5.     int wid;
  6.     int area;
  7. };
  8. bool compute(Data a, Data b) {
  9.     return a.area<b.area;
  10. }
  11. int main(){
  12.     int n;
  13.     cin>>n;
  14.     vector<Data> rectangles(n);

  15.     for (int i=0; i<n;++i)
  16.     {
  17.         cin>>rectangles[i].len>>rectangles[i].wid;
  18.         rectangles[i].area=rectangles[i].len* rectangles[i].wid;
  19.     }
  20.     sort(rectangles.begin(), rectangles.end(),compute);

  21.     for (const auto&i:rectangles) {
  22.         cout<<i.len<<"x"<<i.wid<<"="<<i.area<<endl;
  23.     }
  24.     return 0;
  25. }
複製代碼
    ⪔〠   

TOP

本帖最後由 高鋐鈞 於 2024-9-14 11:26 編輯
  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. struct Data{
  4.     int a,b,c;
  5. };
  6. bool compare(Data n1,Data n2){
  7.     return n2.c>n1.c;
  8. }
  9. int main()
  10. {
  11.     int x;
  12.     cin>>x;
  13.     Data n[x];
  14.     for(int i=0;i<x;i++){
  15.         cin>>n[i].a>>n[i].b;
  16.         n[i].c=n[i].a*n[i].b;
  17.     }
  18.     sort( n,n+x,compare);
  19.     for(int i=0;i<x;i++){
  20.         cout<<n[i].a<<"x"<<n[i].b<<"="<<n[i].c<<endl;
  21.     }
  22.     return 0;
  23. }
複製代碼

TOP

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. struct Data
  4. {
  5.     int a,b,c;
  6. };
  7. bool compare(Data d1,Data d2)
  8. {
  9.     return d2.c>d1.c;
  10. }
  11. int main()
  12. {
  13.     int n;
  14.     cin>>n;
  15.     Data d[n];
  16.     for(int i=0;i<n;i++)
  17.     {
  18.         cin>>d[i].a>>d[i].b;

  19.     d[i].c=d[i].a*d[i].b;
  20.     }
  21.     sort(d,d+n,compare);
  22.     for(int i=0;i<n;i++)
  23.     {
  24.         cout<<d[i].a<<"*"<<d[i].b<<"="<<d[i].c<<endl;
  25.     }
  26.     return 0;
  27. }
複製代碼

TOP

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. struct Data
  4. {
  5.     int a,b,c;
  6. };
  7. bool compare(Data d1,Data d2)
  8. {
  9.     return d2.c>d1.c;
  10. }
  11. int main()
  12. {
  13.     int n;
  14.     cin>>n;
  15.     Data d[n];
  16.     for(int i=0;i<n;i++)
  17.     {
  18.         cin>>d[i].a>>d[i].b;
  19.         d[i].c=d[i].a*d[i].b;
  20.     }
  21.     sort(d,d+n,compare);
  22.     for(int i=0;i<n;i++)
  23.     {
  24.         cout<<d[i].a<<'x'<<d[i].b<<'='<<d[i].c<<endl;
  25.     }
  26.     return 0;
  27. }
複製代碼

TOP

  1. #include<bits/stdc++.h>
  2. using namespace std;
  3. struct Data
  4. {
  5.     int a,b,c;
  6. };
  7. bool compare(Data d1,Data d2){
  8.     return d2.c>d1.c;
  9. }
  10. int main()
  11. {
  12.     int n;
  13.     cin>>n;
  14.     Data d[n];
  15.     for(int i=0;i<n;i++)
  16.     {
  17.         cin>>d[i].a>>d[i].b;
  18.         d[i].c=d[i].a*d[i].b;
  19.     }
  20.     sort(d,d+n,compare);
  21.     for(int i=0;i<n;i++)
  22.     {
  23.         cout<<d[i].a<<"x"<<d[i].b<<"="<<d[i].c<<"\n";
  24.     }
  25.     return 0;
  26. }
複製代碼

TOP

考試時,常常會遇到需要輸入一個整數,然後根據這個整數來配置記憶體的情況。這時候,學生要知道如何有效地利用 C++ 的記憶體配置來解決問題。程式中的 Data d[n] 就是一個典型的例子。

1. Data d[n] 當作動態記憶體配置
在許多考試或練習中,學生可能會先輸入一個整數 n,這個數字決定了接下來需要多少記憶體來儲存資料。像這樣的寫法:
  1. cin >> n;
  2. Data d[n];
複製代碼
這裡的 d[n] 是根據輸入的 n 來配置陣列的空間。雖然看起來很方便,但這其實只是在 C++ 的某些編譯器(如 GCC)中允許的變數長度陣列(Variable Length Arrays, VLA),而不是標準的 C++ 寫法。VLA 是一種能根據變數大小動態分配記憶體的陣列,這種寫法雖然在某些情況下看起來像是動態記憶體分配,但它不是標準的 C++,而且在不同的環境或編譯器中可能無法使用。

標準的做法:使用 new
標準的 C++ 需要使用 new 來真正做到動態記憶體配置,這樣程式在執行時才能依據使用者輸入的數值來分配記憶體,像這樣:
  1. Data* d = new Data[n];
複製代碼
這樣的做法能保證程式在任何標準的 C++ 環境中運作,並且記憶體是根據實際需求動態分配的。
  1. int main()
  2. {
  3.     cin >> n;
  4.     Data* d = new Data[n];  // 動態記憶體配置
  5.     for(int i = 0; i < n; i++)
  6.     {
  7.         cin >> d[i].a >> d[i].b;
  8.         d[i].c = d[i].a * d[i].b;
  9.     }
  10.     sort(d, d+n, compare);
  11.     for(int i = 0; i < n; i++)
  12.         cout << d[i].a << 'x' << d[i].b << '=' << d[i].c << endl;
  13.    
  14.     delete[] d;  // 釋放記憶體
  15.     return 0;
  16. }
複製代碼

TOP

返回列表