完成20-26

Author: MLRichard

exercises/20_function_template/main.cpp

@@ -1,11 +1,10 @@
 #include "../exercise.h"
 
 // READ: 函数模板 <https://zh.cppreference.com/w/cpp/language/function_template>
-// 函数模板定义
-// template<typename T>
-// T plus(T a, T b) {
-//     return a + b;
-// }
+// 函数模板--`template<typename T>`,
+// - 函数模板就像是一个“模具”或“蓝图”。
+// - 不需要为 int、float 或 double 分别编写逻辑相同的函数
+// - // T1 和 T2 可以是不同类型`template <typename T1, typename T2>`
 // TODO: 将这个函数模板化
 // int plus(int a, int b) {
 //     return a + b;

exercises/21_runtime_datatype/main.cpp

@@ -18,13 +18,27 @@ struct TaggedUnion {
 };
 
 // TODO: 将这个函数模板化用于 sigmoid_dyn
-float sigmoid(float x) {
+// float sigmoid(float x) {
+//     return 1 / (1 + std::exp(-x));
+// }
+template<typename T>
+T sigmoid(T x){
     return 1 / (1 + std::exp(-x));
 }
 
 TaggedUnion sigmoid_dyn(TaggedUnion x) {
     TaggedUnion ans{x.type};
     // TODO: 根据 type 调用 sigmoid
+    // 让函数能同时处理 float 和 double
+    switch (x.type)
+    {
+    case DataType::Float:
+        ans.f = sigmoid(x.f);
+        break;
+    case DataType::Double:
+        ans.d = sigmoid(x.d);
+        break;
+    }
     return ans;
 }
 

exercises/22_class_template/main.cpp

@@ -1,7 +1,7 @@
 #include "../exercise.h"
 #include <cstring>
 // READ: 类模板 <https://zh.cppreference.com/w/cpp/language/class_template>
-
+// 类模板（Class Template） 是泛型编程的核心工具。它允许我们编写一个通用的类，而不必为每种数据类型都重写一遍代码。
 template<class T>
 struct Tensor4D {
     unsigned int shape[4];
@@ -10,6 +10,10 @@ struct Tensor4D {
     Tensor4D(unsigned int const shape_[4], T const *data_) {
         unsigned int size = 1;
         // TODO: 填入正确的 shape 并计算 size
+        for (int i = 0; i < 4; i++) {
+            shape[i] = shape_[i];
+            size *= shape[i];
+        }
         data = new T[size];
         std::memcpy(data, data_, size * sizeof(T));
     }
@@ -28,10 +32,47 @@ struct Tensor4D {
     // 则 `this` 与 `others` 相加时，3 个形状为 `[1, 2, 1, 4]` 的子张量各自与 `others` 对应项相加。
     Tensor4D &operator+=(Tensor4D const &others) {
         // TODO: 实现单向广播的加法
+        // 1.预先计算others 的 strides (步长)，用于将 (n,c,h,w) 坐标转换为线性索引
+        // 线性索引 = n * stride_0 + c * stride_1 + h * stride_2 + w * stride_3
+        unsigned int o_stride3=1;
+        unsigned int o_stride2=others.shape[3];
+        unsigned int o_stride1=o_stride2*others.shape[2];
+        unsigned int o_stride0=o_stride1*others.shape[1];
+        //// 使用指针直接遍历 this->data，避免重复计算 this 的线性索引
+        T* current_ptr = this->data;
+        // 4层循环遍历 this 的所有维度
+        for (unsigned int n = 0; n < shape[0]; ++n) {
+            // 如果 others 在该维度长度为1，则索引固定为0（广播），否则跟随 n
+            unsigned int n_idx = (others.shape[0] == 1) ? 0 : n;
+            
+            for (unsigned int c = 0; c < shape[1]; ++c) {
+                unsigned int c_idx = (others.shape[1] == 1) ? 0 : c;
+                
+                for (unsigned int h = 0; h < shape[2]; ++h) {
+                    unsigned int h_idx = (others.shape[2] == 1) ? 0 : h;
+                    
+                    for (unsigned int w = 0; w < shape[3]; ++w) {
+                        unsigned int w_idx = (others.shape[3] == 1) ? 0 : w;
+                        // 计算 others 中的线性偏移量
+                        unsigned int others_offset = 
+                            n_idx * o_stride0 + 
+                            c_idx * o_stride1 + 
+                            h_idx * o_stride2 + 
+                            w_idx * o_stride3;
+                        // 执行加法
+                        *current_ptr += others.data[others_offset];
+                        
+                        // 移动到 this 的下一个元素
+                        ++current_ptr;
+                    }
+                }
+            }
+        }
         return *this;
     }
 };
 
+
 // ---- 不要修改以下代码 ----
 int main(int argc, char **argv) {
     {

exercises/23_template_const/main.cpp

@@ -11,6 +11,11 @@ struct Tensor {
     Tensor(unsigned int const shape_[N]) {
         unsigned int size = 1;
         // TODO: 填入正确的 shape 并计算 size
+        for (unsigned int i = 0; i < N; i++)
+        {
+            shape[i] = shape_[i];
+            size *= shape[i];
+        }
         data = new T[size];
         std::memset(data, 0, size * sizeof(T));
     }
@@ -35,6 +40,7 @@ struct Tensor {
         for (unsigned int i = 0; i < N; ++i) {
             ASSERT(indices[i] < shape[i], "Invalid index");
             // TODO: 计算 index
+            index = index * shape[i] + indices[i];
         }
         return index;
     }

exercises/24_std_array/main.cpp

@@ -4,25 +4,43 @@
 
 // READ: std::array <https://zh.cppreference.com/w/cpp/container/array>
 
+// std::array是对 C 语言风格数组（如 int arr[5]）的现代化封装。
+// - 既保留了原生数组的高性能（零开销）
+// - 又提供了类似 STL 容器（如 std::vector）的安全性和便利性接口。
+// 1.基本语法，需要包含头文件 <array>。
+// - std::array<int, 5> myArray = {1, 2, 3, 4, 5};
+// - 第一个模板参数 int 是数据类型，第二个模板参数 5 是数组大小（必须是编译期常量）。
+// 2.为什么要使用 std::array?
+// - std::array 是一个对象，包含长度消息和数据，不会退化为指针
+// - std::array 支持直接赋值，只要类型和大小相同
+// - std::array 安全性高，提供了 .at() 方法，会进行边界检查。如果越界，会抛出异常
+// - std::array STL兼容性强，提供了迭代器（begin(), end()），可以完美配合 std::sort, std::for_each 等标准算法使用。
+// 3. 主要特性
+// - 内存分配： 与 C 数组一样，数据通常存储在栈（Stack）上（除非它是全局变量或被 new 出来的）。这意味着没有动态内存分配（堆内存）的开销，速度极快。
+// - 固定大小： 大小在编译时必须确定，运行时不能改变（不能像 vector 那样 push_back）。
+// - 零开销： 在优化开启的情况下，std::array 的性能与 C 风格数组完全一致。
+
+// std::memcmp (Memory Compare) 是用来比较两块内存区域的内容是否完全一致的函数
 // TODO: 将下列 `?` 替换为正确的代码
 int main(int argc, char **argv) {
     {
         std::array<int, 5> arr{{1, 2, 3, 4, 5}};
-        ASSERT(arr.size() == ?, "Fill in the correct value.");
-        ASSERT(sizeof(arr) == ?, "Fill in the correct value.");
+        ASSERT(arr.size() == 5, "Fill in the correct value.");//数组大小
+        ASSERT(sizeof(arr) == 20, "Fill in the correct value.");//int 的大小为 4
         int ans[]{1, 2, 3, 4, 5};
-        ASSERT(std::memcmp(arr.?, ans, ?) == 0, "Fill in the correct values.");
+        //比较arr.data 和 ans，长度为 sizeof(ans)
+        ASSERT(std::memcmp(arr.data(), ans, sizeof(ans)) == 0, "Fill in the correct values.");     
     }
     {
         std::array<double, 8> arr;
-        ASSERT(arr.size() == ?, "Fill in the correct value.");
-        ASSERT(sizeof(arr) == ?, "Fill in the correct value.");
+        ASSERT(arr.size() == 8, "Fill in the correct value.");
+        ASSERT(sizeof(arr) == 64, "Fill in the correct value.");//double 的大小为 8
     }
     {
         std::array<char, 21> arr{"Hello, InfiniTensor!"};
-        ASSERT(arr.size() == ?, "Fill in the correct value.");
-        ASSERT(sizeof(arr) == ?, "Fill in the correct value.");
-        ASSERT(std::strcmp(arr.?, "Hello, InfiniTensor!") == 0, "Fill in the correct value.");
+        ASSERT(arr.size() == 21, "Fill in the correct value.");
+        ASSERT(sizeof(arr) == 21, "Fill in the correct value.");//char 的大小为 1
+        ASSERT(std::strcmp(arr.data(), "Hello, InfiniTensor!") == 0, "Fill in the correct value.");
     }
     return 0;
 }

exercises/25_std_vector/main.cpp

@@ -3,86 +3,95 @@
 #include <vector>
 
 // READ: std::vector <https://zh.cppreference.com/w/cpp/container/vector>
-
+// vector 是一种序列容器，它允许你在运行时动态地插入和删除元素。需要使用头文件 <vector>。
 // TODO: 将下列 `?` 替换为正确的代码
 int main(int argc, char **argv) {
     {
         std::vector<int> vec{1, 2, 3, 4, 5};
-        ASSERT(vec.size() == ?, "Fill in the correct value.");
+        ASSERT(vec.size() == 5, "Fill in the correct value.");
         // THINK: `std::vector` 的大小是什么意思？与什么有关？
-        ASSERT(sizeof(vec) == ?, "Fill in the correct value.");
+        // // 在 64 位系统上，sizeof(vector) 通常是 24 (3个指针)
+        ASSERT(sizeof(vec) == 24, "Fill in the correct value.");
         int ans[]{1, 2, 3, 4, 5};
-        ASSERT(std::memcmp(vec.?, ans, sizeof(ans)) == 0, "Fill in the correct values.");
+        ASSERT(std::memcmp(vec.data(), ans, sizeof(ans)) == 0, "Fill in the correct values.");
     }
     {
         std::vector<double> vec{1, 2, 3, 4, 5};
         {
-            ASSERT(vec.size() == ?, "Fill in the correct value.");
-            ASSERT(sizeof(vec) == ?, "Fill in the correct value.");
+            ASSERT(vec.size() == 5, "Fill in the correct value.");
+            ASSERT(sizeof(vec) == 24, "Fill in the correct value.");
             double ans[]{1, 2, 3, 4, 5};
-            ASSERT(std::memcmp(vec.?, ans, sizeof(ans)) == 0, "Fill in the correct values.");
+            ASSERT(std::memcmp(vec.data(), ans, sizeof(ans)) == 0, "Fill in the correct values.");
         }
         {
-            vec.push_back(6);
-            ASSERT(vec.size() == ?, "Fill in the correct value.");
-            ASSERT(sizeof(vec) == ?, "Fill in the correct value.");
-            vec.pop_back();
-            ASSERT(vec.size() == ?, "Fill in the correct value.");
-            ASSERT(sizeof(vec) == ?, "Fill in the correct value.");
+            vec.push_back(6);// 入栈
+            ASSERT(vec.size() == 6, "Fill in the correct value.");
+            ASSERT(sizeof(vec) == 24, "Fill in the correct value.");
+            vec.pop_back();// 出栈
+            ASSERT(vec.size() == 5, "Fill in the correct value.");
+            ASSERT(sizeof(vec) == 24, "Fill in the correct value.");
         }
         {
             vec[4] = 6;
-            ASSERT(vec[0] == ?, "Fill in the correct value.");
-            ASSERT(vec[1] == ?, "Fill in the correct value.");
-            ASSERT(vec[2] == ?, "Fill in the correct value.");
-            ASSERT(vec[3] == ?, "Fill in the correct value.");
-            ASSERT(vec[4] == ?, "Fill in the correct value.");
+            ASSERT(vec[0] == 1, "Fill in the correct value.");
+            ASSERT(vec[1] == 2, "Fill in the correct value.");
+            ASSERT(vec[2] == 3, "Fill in the correct value.");
+            ASSERT(vec[3] == 4, "Fill in the correct value.");
+            ASSERT(vec[4] == 6, "Fill in the correct value.");
         }
         {
             // THINK: `std::vector` 插入删除的时间复杂度是什么？
-            vec.insert(?, 1.5);
+            // insert 插入，在中间或头部插入会导致插入点之后的元素全部向后移动，时间复杂度为 $O(n)$。
+            // - insert 的第一个参数必须是“迭代器”（Iterator），不能是下标。
+            // - 插入单个元素 vec.insert(it+index, element)。;
+            // - 插入多个相同的元素 vec.insert(it+index, count, element)。；
+
+            // auto it=vec.begin();
+            // vec.insert(it+1, 1.5);
+            vec.insert(vec.begin() + 1, 1.5);
             ASSERT((vec == std::vector<double>{1, 1.5, 2, 3, 4, 6}), "Make this assertion pass.");
-            vec.erase(?);
+            vec.erase(vec.begin() + 3);
             ASSERT((vec == std::vector<double>{1, 1.5, 2, 4, 6}), "Make this assertion pass.");
         }
         {
             vec.shrink_to_fit();
-            ASSERT(vec.capacity() == ?, "Fill in the correct value.");
+            ASSERT(vec.capacity() == 5, "Fill in the correct value.");
             vec.clear();
-            ASSERT(vec.empty(), "`vec` is empty now.");
-            ASSERT(vec.size() == ?, "Fill in the correct value.");
-            ASSERT(vec.capacity() == ?, "Fill in the correct value.");
+            ASSERT(vec.empty(), "`vec` is empty now.");// empty不改变capacity
+            ASSERT(vec.size() == 0, "Fill in the correct value.");
+            ASSERT(vec.capacity() == 5, "Fill in the correct value.");
         }
     }
     {
-        std::vector<char> vec(?, ?); // TODO: 调用正确的构造函数
+        std::vector<char> vec(48, 'z'); // TODO: 调用正确的构造函数
         ASSERT(vec[0] == 'z', "Make this assertion pass.");
         ASSERT(vec[47] == 'z', "Make this assertion pass.");
         ASSERT(vec.size() == 48, "Make this assertion pass.");
-        ASSERT(sizeof(vec) == ?, "Fill in the correct value.");
+        ASSERT(sizeof(vec) == 24, "Fill in the correct value.");
         {
-            auto capacity = vec.capacity();
+            // resize改变大小(size)和容量(capacity)
             vec.resize(16);
-            ASSERT(vec.size() == ?, "Fill in the correct value.");
-            ASSERT(vec.capacity() == ?, "Fill in a correct identifier.");
+            ASSERT(vec.size() == 16, "Fill in the correct value.");
+            ASSERT(vec.capacity() == 48, "Fill in a correct identifier.");
         }
         {
+            //reserve预留空间，只改变capacity
             vec.reserve(256);
-            ASSERT(vec.size() == ?, "Fill in the correct value.");
-            ASSERT(vec.capacity() == ?, "Fill in the correct value.");
+            ASSERT(vec.size() == 16, "Fill in the correct value.");
+            ASSERT(vec.capacity() == 256, "Fill in the correct value.");
         }
         {
             vec.push_back('a');
             vec.push_back('b');
             vec.push_back('c');
             vec.push_back('d');
-            ASSERT(vec.size() == ?, "Fill in the correct value.");
-            ASSERT(vec.capacity() == ?, "Fill in the correct value.");
-            ASSERT(vec[15] == ?, "Fill in the correct value.");
-            ASSERT(vec[?] == 'a', "Fill in the correct value.");
-            ASSERT(vec[?] == 'b', "Fill in the correct value.");
-            ASSERT(vec[?] == 'c', "Fill in the correct value.");
-            ASSERT(vec[?] == 'd', "Fill in the correct value.");
+            ASSERT(vec.size() == 20, "Fill in the correct value.");
+            ASSERT(vec.capacity() == 256, "Fill in the correct value.");
+            ASSERT(vec[15] == 'z', "Fill in the correct value.");
+            ASSERT(vec[16] == 'a', "Fill in the correct value.");
+            ASSERT(vec[17] == 'b', "Fill in the correct value.");
+            ASSERT(vec[18] == 'c', "Fill in the correct value.");
+            ASSERT(vec[19] == 'd', "Fill in the correct value.");
         }
     }
 

exercises/26_std_vector_bool/main.cpp

@@ -6,29 +6,29 @@
 
 // TODO: 将下列 `?` 替换为正确的代码
 int main(int argc, char **argv) {
-    std::vector<bool> vec(?, ?);// TODO: 正确调用构造函数
+    std::vector<bool> vec(100, true);// TODO: 正确调用构造函数
     ASSERT(vec[0], "Make this assertion pass.");
     ASSERT(vec[99], "Make this assertion pass.");
     ASSERT(vec.size() == 100, "Make this assertion pass.");
     // NOTICE: 平台相关！注意 CI:Ubuntu 上的值。
     std::cout << "sizeof(std::vector<bool>) = " << sizeof(std::vector<bool>) << std::endl;
-    ASSERT(sizeof(vec) == ?, "Fill in the correct value.");
+    ASSERT(sizeof(vec) == 40, "Fill in the correct value.");
     {
         vec[20] = false;
-        ASSERT(?vec[20], "Fill in `vec[20]` or `!vec[20]`.");
+        ASSERT(!vec[20], "Fill in `vec[20]` or `!vec[20]`.");
     }
     {
         vec.push_back(false);
-        ASSERT(vec.size() == ?, "Fill in the correct value.");
-        ASSERT(?vec[100], "Fill in `vec[100]` or `!vec[100]`.");
+        ASSERT(vec.size() == 101, "Fill in the correct value.");
+        ASSERT(!vec[100], "Fill in `vec[100]` or `!vec[100]`.");
     }
     {
         auto ref = vec[30];
-        ASSERT(?ref, "Fill in `ref` or `!ref`");
+        ASSERT(ref, "Fill in `ref` or `!ref`");
         ref = false;
-        ASSERT(?ref, "Fill in `ref` or `!ref`");
+        ASSERT(!ref, "Fill in `ref` or `!ref`");
         // THINK: WHAT and WHY?
-        ASSERT(?vec[30], "Fill in `vec[30]` or `!vec[30]`.");
+        ASSERT(!vec[30], "Fill in `vec[30]` or `!vec[30]`.");
     }
     return 0;
 }