components:libc:cplusplus:os/utest:Some comments have been initially added.

Some comments have been initially added.
components/libc/cplusplus/os/cxx_Semaphore.cpp
components/libc/cplusplus/os/cxx_Thread.cpp
components/libc/cplusplus/utest/tc_atomic.cpp
components/libc/cplusplus/utest/tc_smartptr.cpp
components/libc/cplusplus/utest/tc_thread.cpp

Signed-off-by:Liu Chengtao<2739960959@qq.com>

Author: lct1001

components/libc/cplusplus/os/cxx_Semaphore.cpp

@@ -11,28 +11,45 @@
 
 using namespace rtthread;
 
+/** 
+ * @brief Semaphore class implementation.
+ */
 Semaphore::Semaphore(const char *name, int32_t count)
 {
+    // Initialize the semaphore with a specified count and FIFO order.
     rt_sem_init(&mID, name, count, RT_IPC_FLAG_FIFO);
 }
 
+/** 
+ * @brief Wait on the semaphore.
+ * @param millisec Timeout in milliseconds.
+ * @return Boolean indicating if the semaphore was successfully taken.
+ */
 bool Semaphore::wait(int32_t millisec)
 {
     rt_int32_t tick;
 
+    // Convert milliseconds to system ticks.
     if (millisec < 0)
         tick = -1;
     else
         tick = rt_tick_from_millisecond(millisec);
 
+    // Attempt to take the semaphore.
     return rt_sem_take(&mID, tick) == RT_EOK;
 }
 
+/** 
+ * @brief Release the semaphore.
+ */
 void Semaphore::release(void)
 {
     rt_sem_release(&mID);
 }
 
+/** 
+ * Detach the semaphore when the object is destroyed.
+ */
 Semaphore::~Semaphore()
 {
     rt_sem_detach(&mID);

components/libc/cplusplus/os/cxx_Thread.cpp

@@ -11,6 +11,9 @@
 
 using namespace rtthread;
 
+/** 
+ * @brief Thread class constructor with parameters for stack size, priority, tick, and name.
+ */
 Thread::Thread(rt_uint32_t stack_size,
                rt_uint8_t  priority,
                rt_uint32_t tick,
@@ -27,6 +30,9 @@ Thread::Thread(rt_uint32_t stack_size,
                                tick);
 }
 
+/** 
+ * @brief Thread class constructor with entry function and parameters.
+ */
 Thread::Thread(void (*entry)(void *p),
                void *p,
                rt_uint32_t stack_size,
@@ -45,12 +51,19 @@ Thread::Thread(void (*entry)(void *p),
                                tick);
 }
 
+/** 
+ * @brief Detach the event and delete the thread when the object is destroyed.
+ */
 Thread::~Thread()
 {
     rt_event_detach(&_event);
     rt_thread_delete(_thread);
 }
 
+/** 
+ * @brief Start the thread execution.
+ * @return Boolean indicating if the thread was successfully started.
+ */
 bool Thread::start()
 {
     if (rt_thread_startup(_thread) == RT_EOK)
@@ -61,20 +74,30 @@ bool Thread::start()
     return started;
 }
 
+/** 
+ * Make the thread sleep for a specified duration.
+ * @param millisec Duration in milliseconds.
+ */
 void Thread::sleep(int32_t millisec)
 {
     rt_int32_t tick;
 
+    // Convert milliseconds to system ticks.
     if (millisec < 0)
         tick = 1;
     else
         tick = rt_tick_from_millisecond(millisec);
 
+    // Delay the thread for a specified number of ticks.
     rt_thread_delay(tick);
 }
 
+/** 
+ * Static function to run the thread's entry function.
+ */
 void Thread::func(Thread *pThis)
 {
+    // If an entry function is provided, execute it.
     if (pThis->_entry != RT_NULL)
     {
         pThis->_entry(pThis->_param);
@@ -84,30 +107,46 @@ void Thread::func(Thread *pThis)
         pThis->run(pThis->_param);
     }
 
+    // Send an event to signal thread completion.
     rt_event_send(&pThis->_event, 1);
 }
 
+/** 
+ * Default run function that can be overridden by subclasses.
+ */
 void Thread::run(void *parameter)
 {
     /* please overload this method */
 }
 
+/** 
+ * Wait for the thread to complete with a timeout.
+ * @param millisec Timeout in milliseconds.
+ * @return Status code indicating the execution status.
+ */
 rt_err_t Thread::wait(int32_t millisec)
 {
     return join(millisec);
 }
 
+/** 
+ * Join the thread with a timeout.
+ * @param millisec Timeout in milliseconds.
+ * @return Status code indicating the execution status.
+ */
 rt_err_t Thread::join(int32_t millisec)
 {
     if (started)
     {
         rt_int32_t tick;
 
+        // Convert milliseconds to system ticks.
         if (millisec < 0)
             tick = -1;
         else
             tick = rt_tick_from_millisecond(millisec);
 
+        // Wait for the thread's completion event.
         return rt_event_recv(&_event, 1, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, tick, RT_NULL);
     }
     else

components/libc/cplusplus/utest/tc_atomic.cpp

@@ -238,12 +238,13 @@ static void test_compare_exchange_weak(void)
     }
     uassert_int_equal(val.load(), 2);
 }
-
+// Test case initialization function.
 static rt_err_t utest_tc_init(void)
 {
     return RT_EOK;
 }
 
+// Test case cleanup function.
 static rt_err_t utest_tc_cleanup(void)
 {
     return RT_EOK;

components/libc/cplusplus/utest/tc_smartptr.cpp

@@ -35,10 +35,16 @@ static void test_shared_ptr(void)
     uassert_int_equal(p1.use_count(), 2);
 }
 
+/**
+ * @brief Test case initialization function.
+ */
 static rt_err_t utest_tc_init(void)
 {
     return RT_EOK;
 }
+/**
+ * @brief Test case cleanup function.
+ */
 
 static rt_err_t utest_tc_cleanup(void)
 {

components/libc/cplusplus/utest/tc_thread.cpp

@@ -12,48 +12,71 @@
 #include "utest.h"
 #include <thread>
 
+
+/**
+ * @brief Function to test thread functionality.
+ */
 static void test_thread(void)
 {
-    int count = 0;
+    int count = 0;  // Initialize a counter to zero.
+
+    // Lambda function to increment the count.
     auto func = [&]() mutable
     {
         for (int i = 0; i < 100; ++i)
         {
-            ++count;
+            ++count;  // Increment the count 100 times.
         }
     };
 
+    // Create and run a thread executing the lambda function.
     std::thread t1(func);
-    t1.join();
+    t1.join();  // Wait for the thread to finish execution.
 
+    // Verify if the count is as expected after the first thread execution.
     if (count != 100)
     {
-        uassert_false(1);
+        uassert_false(1);  // Assert failure if count is not 100.
     }
 
+    // Create and run another thread executing the same lambda function.
     std::thread t2(func);
-    t2.join();
+    t2.join();  // Wait for the second thread to finish execution.
 
+    // Verify if the count is as expected after the second thread execution.
     if (count != 200)
     {
-        uassert_false(1);
+        uassert_false(1);  // Assert failure if count is not 200.
     }
 
+    // If both assertions passed, the test is successful.
     uassert_true(1);
 }
 
+
+/**
+ * @brief Test case initialization function.
+ */
+
 static rt_err_t utest_tc_init(void)
 {
-    return RT_EOK;
+    return RT_EOK;  
 }
-
+/**
+ * @brief Test case cleanup function.
+ */
 static rt_err_t utest_tc_cleanup(void)
 {
-    return RT_EOK;
+    return RT_EOK;  
 }
 
+/**
+ * @brief Main test case function that runs the test.
+ */ 
 static void testcase(void)
 {
     UTEST_UNIT_RUN(test_thread);
 }
+
+// Export the test case with initialization and cleanup functions and a timeout of 10 ticks.
 UTEST_TC_EXPORT(testcase, "components.libc.cpp.thread_tc", utest_tc_init, utest_tc_cleanup, 10);