Từ 1 tới 6 trên tổng số 6 kết quả

Đề tài: Thắc mắc về sự khác nhau giữa việc chạy chương trình bằng F5 (Star Debugging) và Ctrl + F5 (Star Without Debugging)

  1. #1
    Ngày gia nhập
    03 2011
    Bài viết
    11

    Question Thắc mắc về sự khác nhau giữa việc chạy chương trình bằng F5 (Star Debugging) và Ctrl + F5 (Star Without Debugging)

    Như tiêu đề, em có một số thắc mắc khi tiến hành chạy chương trình bằng F5 (Run with Debug) và Ctrl + F5 (Run without Debug).
    Theo như một số thông tin trên mạng em tìm kiếm được cũng khá mơ hồ: khi Run with Debug (F5) chương trình sẽ tự động fix các lỗi phát sinh, ví dụ như xung đột bộ nhớ khi cấp phát (em cũng không chắc là mình dịch đúng)... Còn Ctrl + F5 thì ngược lại, sẽ compile chương trình và chạy bất kể có phát sinh lỗi gì hay không (Không thông báo khi phát sinh lỗi). Không biết em hiểu có đúng không?

    Sau đây là một đoạn code thực hiện các phép tính + - * / trên 2 đa thức, có sự khác biệt về kết quả lúc chạy bằng F5 và Ctrl + F5:

    C++ Code:
    1. #include <iostream>
    2. #include <fstream>
    3. #include <string.h>
    4. using namespace std;
    5.  
    6. struct Operand
    7. {
    8.     double a;//Số hạng
    9.     int power;//Số mũ tương ứng
    10. };
    11. class DATHUC
    12. {
    13. private:
    14.     Operand *m_daThuc;
    15.     int m_n;//số lượng đơn thức
    16. public:
    17.     DATHUC();
    18.     DATHUC(Operand *daThuc, int n);
    19.     DATHUC(const DATHUC &dt);
    20.     ~DATHUC();
    21.     void standardize();
    22.     DATHUC &operator = (const DATHUC &dt);
    23.     DATHUC operator + (const DATHUC &dt) const;
    24.     DATHUC operator - (const DATHUC &dt) const;
    25.     DATHUC operator * (const DATHUC &dt) const;
    26.     DATHUC operator / (const DATHUC &dt) const;
    27.     DATHUC operator % (const DATHUC &dt) const;
    28.     friend istream &operator >> (istream &inputDev, DATHUC &dt);
    29.     friend ostream &operator << (ostream &outputDev, const DATHUC &dt);
    30. };
    31. DaThuc.cpp


    C++ Code:
    1. DATHUC::DATHUC()
    2. {
    3.     m_n = 0;
    4.     m_daThuc = NULL;
    5. }
    6. DATHUC::DATHUC(Operand *daThuc, int n)
    7. {
    8.     m_daThuc = daThuc;
    9.     m_n = n;
    10. }
    11. DATHUC::DATHUC(const DATHUC &dt)
    12. {
    13.     m_n = dt.m_n;
    14.     m_daThuc = new Operand[m_n];
    15.     for (int i = 0; i < m_n; i++)
    16.     {
    17.         m_daThuc[i].a = dt.m_daThuc[i].a;
    18.         m_daThuc[i].power = dt.m_daThuc[i].power;
    19.     }
    20. }
    21. DATHUC::~DATHUC()
    22. {
    23.     delete []m_daThuc;
    24. }
    25. void DATHUC::standardize()
    26. {
    27.     for (int i = 0; i < m_n - 1; i++)
    28.         for (int j = i + 1; j < m_n; j++)
    29.             if (m_daThuc[i].power < m_daThuc[j].power)
    30.             {
    31.                 Operand Temp = m_daThuc[i];
    32.                 m_daThuc[i] = m_daThuc[j];
    33.                 m_daThuc[j] = Temp;
    34.             }
    35.     int new_n;
    36.     new_n = 1;
    37.     for (int i = 1; i < m_n; i++)
    38.         if (m_daThuc[i].power == m_daThuc[i-1].power)
    39.         {
    40.             m_daThuc[i].a += m_daThuc[i-1].a;
    41.         }
    42.         else
    43.         {
    44.             new_n++;
    45.         }
    46.     int k = 0;
    47.     Operand *temp_daThuc = new Operand[new_n];
    48.     for (int i = 0; i < m_n; i++)
    49.         if (i == m_n || m_daThuc[i].power != m_daThuc[i+1].power )
    50.         {
    51.             if (m_daThuc[i].a != 0)
    52.             {
    53.                 temp_daThuc[k].power = m_daThuc[i].power;
    54.                 temp_daThuc[k].a = m_daThuc[i].a;
    55.                 k++;
    56.             }
    57.         }
    58.     new_n = k;
    59.  
    60.     m_daThuc = new Operand[new_n];
    61.     m_n = new_n;
    62.     for (int i = 0; i < new_n; i++)
    63.         m_daThuc[i] = temp_daThuc[i];
    64.     delete []temp_daThuc;
    65. }
    66. DATHUC &DATHUC::operator = (const DATHUC &dt)
    67. {
    68.     m_n = dt.m_n;
    69.     m_daThuc = new Operand[m_n];
    70.     for (int i = 0; i < m_n; i++)
    71.     {
    72.         m_daThuc[i].a = dt.m_daThuc[i].a;
    73.         m_daThuc[i].power = dt.m_daThuc[i].power;
    74.     }
    75.     return *this;
    76. }
    77. DATHUC DATHUC::operator + (const DATHUC &dt) const
    78. {
    79.     if (dt.m_daThuc[0].a == 0)
    80.         return *this;
    81.     if (m_daThuc[0].a == 0)
    82.         return dt;
    83.     DATHUC Temp;
    84.     Temp.m_daThuc = new Operand[m_n + dt.m_n];
    85.     for (int i = 0; i < m_n; i++)
    86.         Temp.m_daThuc[i] = m_daThuc[i];
    87.     for (int i = 0; i < dt.m_n; i++)
    88.         Temp.m_daThuc[i + m_n] = dt.m_daThuc[i];
    89.     Temp.m_n = m_n + dt.m_n;
    90.  
    91.     Temp.standardize();
    92.     return Temp;
    93. }
    94. DATHUC DATHUC::operator - (const DATHUC &dt) const
    95. {
    96.     if (dt.m_daThuc[0].a == 0)
    97.         return *this;
    98.     if (m_daThuc[0].a == 0)
    99.         return dt;
    100.  
    101.     DATHUC Temp;
    102.     Temp.m_daThuc = new Operand[m_n + dt.m_n];
    103.     for (int i = 0; i < m_n; i++)
    104.         Temp.m_daThuc[i] = m_daThuc[i];
    105.     for (int i = 0; i < dt.m_n; i++)
    106.     {
    107.         Temp.m_daThuc[i + m_n] = dt.m_daThuc[i];
    108.         Temp.m_daThuc[i + m_n].a *= -1;
    109.     }
    110.     Temp.m_n = m_n + dt.m_n;
    111.     Temp.standardize();
    112.     return Temp;
    113. }
    114. DATHUC DATHUC::operator * (const DATHUC &dt) const
    115. {
    116.     DATHUC Temp, Result,tt;
    117.     Temp.m_n = dt.m_n;
    118.     Temp.m_daThuc = new Operand[Temp.m_n];
    119.     Result.m_daThuc = new Operand[dt.m_n+m_n];
    120.     Result.m_daThuc[0].a = 0;
    121.     for (int i = 0; i < m_n; i++)
    122.     {
    123.         for (int j = 0; j < dt.m_n; j++)
    124.         {
    125.             Temp.m_daThuc[j].a = m_daThuc[i].a * dt.m_daThuc[j].a;
    126.             Temp.m_daThuc[j].power = m_daThuc[i].power + dt.m_daThuc[j].power;
    127.         }
    128.         Result = Result + Temp;
    129.     }
    130.     return Result;
    131. }
    132. DATHUC DATHUC::operator / (const DATHUC &dt) const
    133. {
    134.     DATHUC Temp;
    135.     Temp.m_n = 0;
    136.     Temp.m_daThuc = new Operand[1];
    137.     Temp.m_daThuc[0].a = 0;
    138.     Temp.m_daThuc[0].power = 0;
    139.     if (m_daThuc[0].power < dt.m_daThuc[0].power)
    140.         return Temp;
    141.     Temp.m_n = m_daThuc[0].power - dt.m_daThuc[0].power;
    142.     Temp.m_daThuc = new Operand[Temp.m_n];
    143.     DATHUC dt1_copy (*this);
    144.     DATHUC result;
    145.     result.m_n = 1;
    146.     result.m_daThuc = new Operand[1];
    147.  
    148.     for (int i = 0; i < Temp.m_n; i++)
    149.     {
    150.         Temp.m_daThuc[i].a = dt1_copy.m_daThuc[0].a / dt.m_daThuc[0].a;
    151.         Temp.m_daThuc[i].power = dt1_copy.m_daThuc[i].power - dt.m_daThuc[i].power;
    152.         result.m_daThuc[0].a = Temp.m_daThuc[i].a;
    153.         result.m_daThuc[0].power = Temp.m_daThuc[i].power;
    154.         dt1_copy = dt1_copy - (result * dt);
    155.     }
    156.     Temp.standardize();
    157.     return Temp;
    158. }
    159. DATHUC DATHUC::operator % (const DATHUC &dt) const
    160. {
    161.     if (m_n < dt.m_n)
    162.         return *this;
    163.     return *this - (*this / dt) * dt;
    164. }
    165. istream &operator >> (istream &inputDev, DATHUC &dt)
    166. {
    167.     char tmpCh, tmpStr[1000];
    168.     inputDev.getline(tmpStr,1000);
    169.     dt.m_n = 0;
    170.     for (int i = 0; i < strlen(tmpStr); i++)
    171.         if (tmpStr[i] == '(')
    172.             dt.m_n++;
    173.     dt.m_daThuc = new Operand[dt.m_n];
    174.     int k = -1;
    175.     string buffer ="";
    176.     char *strNum;
    177.     for (int i = 0; i < strlen(tmpStr); i++)
    178.     {
    179.         if (tmpStr[i] == '(')
    180.         {
    181.             k++;
    182.         }
    183.         else
    184.         {
    185.             if (tmpStr[i] == ',')
    186.             {
    187.                 strNum = new char [buffer.length()+1];
    188.                 strcpy(strNum,buffer.c_str());
    189.                 dt.m_daThuc[k].a = atof(strNum);
    190.                 delete[] strNum;
    191.                 buffer = "";
    192.             }
    193.             else
    194.                 if (tmpStr[i] == ')')
    195.                 {
    196.                     strNum = new char [buffer.length()+1];
    197.                     strcpy(strNum,buffer.c_str());
    198.                     dt.m_daThuc[k].power = atoi(strNum);
    199.                     delete[] strNum;
    200.                     buffer = "";
    201.                 }
    202.                 else
    203.                 {
    204.                     buffer += tmpStr[i];
    205.                 }
    206.         }
    207.     }
    208.     dt.standardize();
    209.     return inputDev;
    210. }
    211. ostream &operator << (ostream &outputDev, const DATHUC &dt)
    212. {
    213.     if (dt.m_n == 0 || dt.m_daThuc[0].a == 0)
    214.         outputDev << "0";
    215.     for (int i = 0; i < dt.m_n; i++)
    216.         if (dt.m_daThuc[i].a != 0)
    217.         {
    218.             if (dt.m_daThuc[i].a != 1 || (dt.m_daThuc[i].a == 1 && dt.m_daThuc[i].power == 0))
    219.                 outputDev << dt.m_daThuc[i].a;
    220.             if (dt.m_daThuc[i].power == 1)
    221.                 outputDev << "x";
    222.             else
    223.                 if (dt.m_daThuc[i].power > 0)
    224.                     outputDev << "x^" << dt.m_daThuc[i].power;
    225.             if (i != dt.m_n - 1)
    226.                 if (dt.m_daThuc[i+1].a > 0)
    227.                     outputDev << " + ";
    228.             else
    229.                 outputDev << " ";
    230.         }
    231.    
    232.     outputDev << endl;
    233.     return outputDev;
    234. }

    C++ Code:
    1. #include "DaThuc.h"
    2.  
    3.  
    4. void main()
    5. {
    6.     DATHUC dt1,dt2;
    7.     ifstream fileIn;
    8.     fileIn.open("input.txt");
    9.     if (fileIn == NULL)
    10.     {
    11.         cout << "Khong mo duoc file Input" ;
    12.         return;
    13.     }
    14.     fileIn >> dt1;
    15.     fileIn >> dt2;
    16.     fileIn.close();
    17.     ofstream fileOut;
    18.     fileOut.open("output.txt");
    19.     if (fileOut == NULL)
    20.     {
    21.         cout << "Khong mo duoc file Output" ;
    22.         return;
    23.     }
    24.     fileOut << dt1 + dt2;
    25.     fileOut << dt1 - dt2;
    26.     fileOut << dt1 * dt2;
    27.     fileOut << dt1 / dt2;
    28.     fileOut << dt1 % dt2;
    29.     fileOut.close();
    30.  
    31. }

    Còn đây là nội dung file input.txt (số đầu tiên là số hạng, số thứ hai là bậc của đơn thức)
    Code:
    (1,6) (-1,5) (1,4) (-1,3) (1,2) (-1,1) (1,0)
    (1,2) (-2,1) (3,0)
    Nội dung file output.txt:
    - Chạy bằng F5:


    Code:
    x^6 -1x^5 + x^4 -1x^3 + 2x^2 -3x + 4
    x^6 -1x^5 + x^4 -1x^3 + x -2
    x^8 -3x^7 + 6x^6 -6x^5 + 6x^4 -6x^3 + 6x^2 -5x + 3
    x^4 + x^3 -4x -7
    -3x + 22
    - Chạy bằng Ctrl + F5:
    Code:

    Code:
    x^6 -1x^5 + x^4 -1x^3 + 2x^2 -3x + 4
    x^6 -1x^5 + x^4 -1x^3 + x -2
    x^8 -3x^7 + 6x^6 -6x^5 + 6x^4 -6x^3 + 6x^2 -5x + 3
    x^4 + x^3 -4x -7
    -7x^2 + 11x + 1 + 7 -14 + 21
    Có sự khác nhau ở hàng cuối cùng (phép chia đa thức lấy phần dư. Em không rõ lý do, cách phát hiện và khắc phục nó như thế nào. Mọi người giải thích hộ ạh.

    p/s: Code em trình bày không được đẹp, mọi người cố gắng đọc ạh ^^!

  2. #2
    Ngày gia nhập
    07 2011
    Bài viết
    160

    Nhận xét đầu tiên là cấu trúc dữ liệu của bạn phức tạp hơn mức cần thiết, do vậy code nhìn cũng rất dài và rối. Để lưu 1 đa thức chỉ cần 1 mảng 1 chiều là đủ (số mũ không cần lưu, phần tử a[i] chính là số hạng với số mũ i)

    Do phức tạp nên dễ sai sót chưa nhìn hết nhưng ví dụ trong operator *, bạn chưa khởi tạo đủ cho biến Result (Result.m_n? Các số hạng?) mà đã xài Result = Result + Temp;

  3. #3
    Ngày gia nhập
    10 2011
    Bài viết
    552

    Trích dẫn Nguyên bản được gửi bởi fbchicken Xem bài viết
    Nhận xét đầu tiên là cấu trúc dữ liệu của bạn phức tạp hơn mức cần thiết, do vậy code nhìn cũng rất dài và rối. Để lưu 1 đa thức chỉ cần 1 mảng 1 chiều là đủ (số mũ không cần lưu, phần tử a[i] chính là số hạng với số mũ i)

    Do phức tạp nên dễ sai sót chưa nhìn hết nhưng ví dụ trong operator *, bạn chưa khởi tạo đủ cho biến Result (Result.m_n? Các số hạng?) mà đã xài Result = Result + Temp;
    Theo mình thì biêu diễn đa thức = DSLK sẽ có lợi hơn về mặt lưu trữ chứ ?
    Giả sử đa thức là : 1+ x + 2x^4 , 1+ x^10 ... chẳng hạn . Mảng sẽ là {1,1,0,0,2} và {1,0,0,0,0,0,0,0,0,0,1}
    Nếu biểu diễn theo mảng thì nó bị thừa những phần tử có hệ số = 0 trong mảng . Thực ra thì ko sai nhưng nhìn rất khó chịu . Những đơn thức đi kèm hệ số =0 bị thừa ra mà chúng ta ko nên biểu diễn chúng làm gì cho mệt
    Chưa kể chúng ta sẽ phải thực hiện các phép toán dư thừa ko cần thiết trong đó bởi sự dư thừa những phần tử =0 như trên.
    DSLK khắc phục điều đó
    Đôi điều ngu ý chia sẻ với bạn
    Đã được chỉnh sửa lần cuối bởi clchicken : 29-10-2011 lúc 10:49 PM.

  4. #4
    Ngày gia nhập
    07 2011
    Bài viết
    160

    Trích dẫn Nguyên bản được gửi bởi clchicken Xem bài viết
    Theo mình thì biêu diễn đa thức = DSLK sẽ có lợi hơn về mặt lưu trữ chứ ?
    Giả sử đa thức là : 1+ x + 2x^4 , 1+ x^10 ... chẳng hạn . Mảng sẽ là {1,1,0,0,2} và {1,0,0,0,0,0,0,0,0,0,1}
    Nếu biểu diễn theo mảng thì nó bị thừa những phần tử có hệ số = 0 trong mảng . Thực ra thì ko sai nhưng nhìn rất khó chịu . Những đơn thức đi kèm hệ số =0 bị thừa ra mà chúng ta ko nên biểu diễn chúng làm gì cho mệt
    Chưa kể chúng ta sẽ phải thực hiện các phép toán dư thừa ko cần thiết trong đó bởi sự dư thừa những phần tử =0 như trên.
    DSLK khắc phục điều đó
    Đôi điều ngu ý chia sẻ với bạn
    Vậy thì phải xét xem mục đích là gì
    "Nhìn rất khó chịu" ? Khi nào thì bạn "nhìn" đến những phần tử 0 đó?

    Về cơ bản thì thiết kế càng đơn giản càng đỡ sai và càng tốn ít công implement. Đối với project bình thường, thì ưu tiên cao nhất hay được đặt ở hiệu quả (implement nhanh) + tính trong sáng của code (dễ bảo trì, dễ phát triển tiếp, dễ teamwork).

    Còn nếu thực tế yêu cầu tiết kiệm bộ nhớ / tốc độ tính toán tối ưu thì sẽ phải xét nên lưu trữ thế nào, tùy thuộc vào dạng của đa thức mà chương trình hay phải xử lý. Giả sử hầu hết các đa thức cần xử lý đều có dạng x^100 + 1 hay x^1000 + 1 thì đương nhiên cách lưu trữ "thưa" là hợp lý. Nhưng trường hợp này ít gặp thôi.
    Còn ví dụ với đa thức x^10 + 1, dù cách lưu trữ mảng sẽ thừa ra tận 9 số 0, nhưng chưa chắc đã tốn nhiều bộ nhớ hơn và chạy chậm hơn cách kia đâu nhé! Mình dự đoán là chạy còn nhanh hơn.. Bạn không tin thì cứ thử

    Còn nếu ở đây là bài tập và không có yêu cầu phải lưu trữ "thưa", thì càng không nên phức tạp hóa vấn đề. Nếu có giới hạn bậc của đa thức thì thậm chí dùng mảng tĩnh luôn. (Code của chủ top đầy những lỗi mem leak)

  5. #5
    Ngày gia nhập
    10 2011
    Bài viết
    552

    Trích dẫn Nguyên bản được gửi bởi fbchicken Xem bài viết
    Vậy thì phải xét xem mục đích là gì
    "Nhìn rất khó chịu" ? Khi nào thì bạn "nhìn" đến những phần tử 0 đó?

    Về cơ bản thì thiết kế càng đơn giản càng đỡ sai và càng tốn ít công implement. Đối với project bình thường, thì ưu tiên cao nhất hay được đặt ở hiệu quả (implement nhanh) + tính trong sáng của code (dễ bảo trì, dễ phát triển tiếp, dễ teamwork).

    Còn nếu thực tế yêu cầu tiết kiệm bộ nhớ / tốc độ tính toán tối ưu thì sẽ phải xét nên lưu trữ thế nào, tùy thuộc vào dạng của đa thức mà chương trình hay phải xử lý. Giả sử hầu hết các đa thức cần xử lý đều có dạng x^100 + 1 hay x^1000 + 1 thì đương nhiên cách lưu trữ "thưa" là hợp lý. Nhưng trường hợp này ít gặp thôi.
    Còn ví dụ với đa thức x^10 + 1, dù cách lưu trữ mảng sẽ thừa ra tận 9 số 0, nhưng chưa chắc đã tốn nhiều bộ nhớ hơn và chạy chậm hơn cách kia đâu nhé! Mình dự đoán là chạy còn nhanh hơn.. Bạn không tin thì cứ thử

    Còn nếu ở đây là bài tập và không có yêu cầu phải lưu trữ "thưa", thì càng không nên phức tạp hóa vấn đề. Nếu có giới hạn bậc của đa thức thì thậm chí dùng mảng tĩnh luôn. (Code của chủ top đầy những lỗi mem leak)
    Thanks bạn. Hôm qua đọc mấy cái tip tối ưu mã nguồn và hạn chế mem leak đã ngộ ra nhiều điều.
    Sr vì đã ngu mà còn tỏ ra nguy hiểm

  6. #6
    Ngày gia nhập
    01 2011
    Nơi ở
    \WINDOWS\Assembly\
    Bài viết
    54

    Mặc định Thắc mắc về sự khác nhau giữa việc chạy chương trình bằng F5 (Star Debugging) và Ctrl + F5 (Star Without Debugging)

    Theo mình (ý kiến chủ quan):
    start with debug: chạy chương trình và nếu xảy ra lỗi thì chương trình sẽ dừng và ide sẽ chỉ ngay dòng bị lỗi
    start without debug: cũng chạy chương trình nhưng nếu gặp lỗi thì sẽ xử lý như khi chương trình chạy độc lập

Các đề tài tương tự

  1. Star Trek Into Darkness - Star Trek: Chìm Vào Bóng Tối Full HD miễn phí xem phim trong 1 tháng
    Gửi bởi thanhgetecco123 trong diễn đàn Giới thiệu website, sản phẩm của bạn
    Trả lời: 0
    Bài viết cuối: 31-10-2013, 02:30 PM
  2. MS SQL Lỗi làm sao sửa lỗi configure firewall for remote debugging
    Gửi bởi kid_1412 trong diễn đàn Thắc mắc Microsoft SQL Server & Microsoft Access
    Trả lời: 1
    Bài viết cuối: 02-12-2012, 11:16 PM
  3. Khi Debugging tên form không thay đổi là do đâu?
    Gửi bởi tanthiluong trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 5
    Bài viết cuối: 29-11-2012, 05:25 PM
  4. Phương pháp HTTP Debugging ?
    Gửi bởi haian trong diễn đàn Thắc mắc lập trình C/C++/C++0x
    Trả lời: 1
    Bài viết cuối: 22-04-2010, 11:23 AM
  5. cho mình hỏi lỗi này là lỗi j`[required for OLE Remote Procedure Call debugging]
    Gửi bởi www trong diễn đàn Thắc mắc lập trình Visual C++
    Trả lời: 1
    Bài viết cuối: 18-10-2007, 11:26 AM

Tags của đề tài này

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn