Trang 1 trên tổng số 2 12 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 11 kết quả

Đề tài: thắc mắc về code c++

  1. #1
    Ngày gia nhập
    04 2008
    Bài viết
    0

    Mặc định thắc mắc về code c++

    các bác giúp em hiểu mấy bài code này với ,thầy em bảo dịch từ bản tiếng anh xong rùi làm thuyết trình hic hic ,mấy cái này dịch đã khổ rùi ,nhìn còn lạ hơắc ,bác nào hảo tâm giúp em cái.em xin cảm ơn và hậu tạ (hic tuần tới em pải nộp bài rùi)
    C++ Code:
    1.     Stash with constructors and destructors
    2. //: C06:Stash2.h
    3. // With constructors & destructors
    4. #ifndef STASH2_H
    5. #define STASH2_H
    6.  
    7. class Stash {
    8.   int size;      // Size of each space
    9.   int quantity;  // Number of storage spaces
    10.   int next;      // Next empty space
    11.   // Dynamically allocated array of bytes:
    12.   unsigned char* storage;
    13.   void inflate(int increase);
    14. public:
    15.   Stash(int size);
    16.   ~Stash();
    17.   int add(void* element);
    18.   void* fetch(int index);
    19.   int count();
    20. };
    21. #endif // STASH2_H ///:~
    Định nghĩa thành viên của hàm được thay đổi là initialize() và cleanup(), chúng được thay thế bởi hàm tạo và hàm hủy.
    C++ Code:
    1. //: C06:Stash2.cpp {O}
    2. // Constructors & destructors
    3. #include "Stash2.h"
    4. #include <iostream>
    5. #include <cassert>
    6. using namespace std;
    7. const int increment = 100;
    8.  
    9. Stash::Stash(int sz) {
    10.   size = sz;
    11.   quantity = 0;
    12.   storage = 0;
    13.   next = 0;
    14. }
    15.  
    16. int Stash::add(void* element) {
    17.   if(next >= quantity) // Enough space left?
    18.     inflate(increment);
    19.   // Copy element into storage,
    20.   // starting at next empty space:
    21.   int startBytes = next * size;
    22.   unsigned char* e = (unsigned char*)element;
    23.   for(int i = 0; i < size; i++)//: C06:Stash2.h
    24. // With constructors & destructors
    25. #ifndef STASH2_H
    26. #define STASH2_H
    C++ Code:
    1. class Stash {
    2.   int size;      // Size of each space
    3.   int quantity;  // Number of storage spaces
    4.   int next;      // Next empty space
    5.   // Dynamically allocated array of bytes:
    6.   unsigned char* storage;
    7.   void inflate(int increase);
    8. public:
    9.   Stash(int size);
    10.   ~Stash();
    11.   int add(void* element);
    12.   void* fetch(int index);
    13.   int count();
    14. };
    15. #endif // STASH2_H ///:~
    Định nghĩa thành viên của hàm được thay đổi là initialize() và cleanup(), chúng được thay thế bởi hàm tạo và hàm hủy.
    C++ Code:
    1. //: C06:Stash2.cpp {O}
    2. // Constructors & destructors
    3. #include "Stash2.h"
    4. #include <iostream>
    5. #include <cassert>
    6. using namespace std;
    7. const int increment = 100;
    8.  
    9. Stash::Stash(int sz) {
    10.   size = sz;
    11.   quantity = 0;
    12.   storage = 0;
    13.   next = 0;
    14. }
    15.  
    16. int Stash::add(void* element) {
    17.   if(next >= quantity) // Enough space left?
    18.     inflate(increment);
    19.   // Copy element into storage,
    20.   // starting at next empty space:
    21.   int startBytes = next * size;
    22.   unsigned char* e =
    23.  
    24.     storage[startBytes + i] = e[i];
    25.   next++;
    26.   return(next - 1); // Index number
    27. }
    28.  
    29. void* Stash::fetch(int index) {
    30.   assert(0 <= index && index < next);
    31.   // Produce pointer to desired element:
    32.   return &(storage[index * size]);
    33. }
    34.  
    35. int Stash::count() {
    36.   return next; // Number of elements in CStash
    37. }
    38.  
    39. void Stash::inflate(int increase) {
    40.   assert(increase > 0);
    41.   int newQuantity = quantity + increase;
    42.   int newBytes = newQuantity * size;
    43.   int oldBytes = quantity * size;
    44.   unsigned char* b = new unsigned char[newBytes];
    45.   for(int i = 0; i < oldBytes; i++)
    46.     b[i] = storage[i]; // Copy old to new
    47.   delete [](storage); // Old storage
    48.   storage = b; // Point to new memory
    49.   quantity = newQuantity;
    50. }
    51.  
    52. Stash::~Stash() {
    53.   if(storage != 0) {
    54.    cout << "freeing storage" << endl;
    55.    delete []storage;
    56.   }
    57. } ///:~
    58. .fetch(" << k << ") = "
    59.         << cp << endl;
    60. } ///:~
    Hãy xem inflate(), có lẽ bạn hỏi tại sao assert() vẫn được sử dụng sau hàm required.h (đã được giới thiệu). Sự khác biệt quan trọng: trong quyển sách này assert() sẽ được sử dụng để theo dõi lỗi chương trình. Trong khi require.h là một hàm được thiết kế đặc biệt để sử dụng hợp lý cho người dùng.
    Bởi vì inflate() là phần riêng, chỉ assert() có thể xuất hiện…
    Chú ý: Theo chương trình kiểm tra, định nghĩa thế nào cho đối tượng Stash xuất hiện trước khi chúng được cần đến, khởi tạo như một phần của việc định nghĩa. Trong cấu trúc hàm tạo:
    C++ Code:
    1. //: C06:Stash2Test.cpp
    2. //{L} Stash2
    3. // Constructors & destructors
    4. #include "Stash2.h"
    5. #include "../require.h"
    6. #include <fstream>
    7. #include <iostream>
    8. #include <string>
    9. using namespace std;
    10.  
    11. int main() {
    12.   Stash intStash(sizeof(int));
    13.   for(int i = 0; i < 100; i++)
    14.     intStash.add(&i);
    15.   for(int j = 0; j < intStash.count(); j++)
    16.     cout << "intStash.fetch(" << j << ") = "
    17.          << *(int*)intStash.fetch(j)
    18.          << endl;
    19.   const int bufsize = 80;
    20.   Stash stringStash(sizeof(char) * bufsize);
    21.   ifstream in("Stash2Test.cpp");
    22.   assure(in, " Stash2Test.cpp");
    23.   string line;
    24.   while(getline(in, line))
    25.     stringStash.add((char*)line.c_str());
    26.   int k = 0;
    27.   char* cp;
    28.   while((cp = (char*)stringStash.fetch(k++))!=0)
    29.     cout << "stringStash

    Lứu ý bỏ code vào thẻ code !
    Đã được chỉnh sửa lần cuối bởi rox_rook : 06-04-2008 lúc 04:46 PM.

  2. #2
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    require.h ? Where's it ? ?
    one of my favorite book : thinking in C++ !
    Post code lại hoàn chỉnh coi cậu, cậu copy và paste cũng không nên thân nữa à ?

  3. #3
    Ngày gia nhập
    04 2008
    Bài viết
    0

    hic ,bác thông cảm cho em vì vùi đầu vào cái đống ấy mà em hơi bị ngộ .mà cái require.h em cũng chẳng hiểu ji_lạ hoắc đấy đúng là ở quyển thinking in c++.bác có thể nói rõ cho em mỗi dòng lệnh nói ji dc ko ạ.em học bên kinh tế nên .......hic ko hiêu rõ cho lắm.Mong bác phúc đáp cho em sớm

  4. #4
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    haha cậu học kinh tế mà ông nào đưa cậu cái đống bùi bui kia thế ? Cái này dùng style C mixed C++, void* pointer là very poor style. Dùng generic template code sẽ sáng hơn rất nhiều.
    - Sách đó tui đọc cũng lâu rùi, cậu thắc mắc dòng nào thì tui sẽ giải thích. Còn nếu mỗi dòng lệnh từ A->Z thì tui nghĩ cậu cũng biết đùa

  5. #5
    Ngày gia nhập
    04 2008
    Bài viết
    0

    Guaranteed cleanup with the destructor
    C++ Code:
    1. //: C06:Constructor1.cpp
    2. // Constructors & destructors
    3. #include <iostream>
    4. using namespace std;
    5.  
    6. class Tree {
    7.   int height;
    8. public:
    9.   Tree(int initialHeight);  // Constructor
    10.   ~Tree();  // Destructor
    11.   void grow(int years);
    12.   void printsize();
    13. };
    14.  
    15. Tree::Tree(int initialHeight) {
    16.   height = initialHeight;
    17. }
    18.  
    19. Tree::~Tree() {
    20.   cout << "inside Tree destructor" << endl;
    21.   printsize();
    22. }
    23.  
    24. void Tree::grow(int years) {
    25.   height += years;
    26. }
    27.  
    28. void Tree::printsize() {
    29.   cout << "Tree height is " << height << endl;
    30. }
    31.  
    32. int main() {
    33.   cout << "before opening brace" << endl;
    34.   {
    35.     Tree t(12);
    36.     cout << "after Tree creation" << endl;
    37.     t.printsize();
    38.     t.grow(4);
    39.     cout << "before closing brace" << endl;
    40.   }
    41.   cout << "after closing brace" << endl;
    42. } ///:~


    C++ Code:
    1. Elimination of the definition block
    2. //: C06:DefineInitialize.cpp
    3. // Defining variables anywhere
    4. #include "../require.h"
    5. #include <iostream>
    6. #include <string>
    7. using namespace std;
    8.  
    9. class G {
    10.   int i;
    11. public:
    12.   G(int ii);
    13. };
    14.  
    15. G::G(int ii) { i = ii; }
    16.  
    17. int main() {
    18.   cout << "initialization value? ";
    19.   int retval = 0;
    20.   cin >> retval;
    21.   require(retval != 0);
    22.   int y = retval + 3;
    23.   G g(y);
    24. } ///:~


    C++ Code:
    1. Storage Allocation(Kho lưu trữ)
    2. //: C06:Nojump.cpp
    3. // Can't jump past constructors
    4.  
    5. class X {
    6. public:
    7.   X();
    8. };
    9.  
    10. X::X() {}
    11.  
    12. void f(int i) {
    13.   if(i < 10) {
    14.    //! goto jump1; // Error: goto bypasses init
    15.   }
    16.   X x1;  // Constructor called here
    17.  jump1:
    18.   switch(i) {
    19.     case 1 :
    20.       X x2;  // Constructor called here
    21.       break;
    22.   //! case 2 : // Error: case bypasses init
    23.       X x3;  // Constructor called here
    24.       break;
    25.   }
    26. }
    27.  
    28. int main() {
    29.   f(9);
    30.   f(11);
    31. }///:~







    C++ Code:
    1.      
    2. Stash with constructors and destructors
    3. //: C06:Stash2.h
    4. // With constructors & destructors
    5. #ifndef STASH2_H
    6. #define STASH2_H
    7.  
    8. class Stash {
    9.   int size;      // Size of each space
    10.   int quantity;  // Number of storage spaces
    11.   int next;      // Next empty space
    12.   // Dynamically allocated array of bytes:
    13.   unsigned char* storage;
    14.   void inflate(int increase);
    15. public:
    16.   Stash(int size);
    17.   ~Stash();
    18.   int add(void* element);
    19.   void* fetch(int index);
    20.   int count();
    21. };
    22. #endif // STASH2_H ///:~
    Định nghĩa thành viên của hàm được thay đổi là initialize() và cleanup(), chúng được thay thế bởi hàm tạo và hàm hủy.
    C++ Code:
    1. //: C06:Stash2.cpp {O}
    2. // Constructors & destructors
    3. #include "Stash2.h"
    4. #include <iostream>
    5. #include <cassert>
    6. using namespace std;
    7. const int increment = 100;
    8.  
    9. Stash::Stash(int sz) {
    10.   size = sz;
    11.   quantity = 0;
    12.   storage = 0;
    13.   next = 0;
    14. }
    15.  
    16. int Stash::add(void* element) {
    17.   if(next >= quantity) // Enough space left?
    18.     inflate(increment);
    19.   // Copy element into storage,
    20.   // starting at next empty space:
    21.   int startBytes = next * size;
    22.   unsigned char* e = (unsigned char*)element;
    23.   for(int i = 0; i < size; i++)
    24.     storage[startBytes + i] = e[i];
    25.   next++;
    26.   return(next - 1); // Index number
    27. }
    28.  
    29. void* Stash::fetch(int index) {
    30.   assert(0 <= index && index < next);
    31.   // Produce pointer to desired element:
    32.   return &(storage[index * size]);
    33. }
    34.  
    35. int Stash::count() {
    36.   return next; // Number of elements in CStash
    37. }
    38.  
    39. void Stash::inflate(int increase) {
    40.   assert(increase > 0);
    41.   int newQuantity = quantity + increase;
    42.   int newBytes = newQuantity * size;
    43.   int oldBytes = quantity * size;
    44.   unsigned char* b = new unsigned char[newBytes];
    45.   for(int i = 0; i < oldBytes; i++)
    46.     b[i] = storage[i]; // Copy old to new
    47.   delete [](storage); // Old storage
    48.   storage = b; // Point to new memory
    49.   quantity = newQuantity;
    50. }
    51.  
    52. Stash::~Stash() {
    53.   if(storage != 0) {
    54.    cout << "freeing storage" << endl;
    55.    delete []storage;
    56.   }
    57. } ///:~


    C++ Code:
    1. //: C06:Stash2Test.cpp
    2. //{L} Stash2
    3. // Constructors & destructors
    4. #include "Stash2.h"
    5. #include "../require.h"
    6. #include <fstream>
    7. #include <iostream>
    8. #include <string>
    9. using namespace std;
    10.  
    11. int main() {
    12.   Stash intStash(sizeof(int));
    13.   for(int i = 0; i < 100; i++)
    14.     intStash.add(&i);
    15.   for(int j = 0; j < intStash.count(); j++)
    16.     cout << "intStash.fetch(" << j << ") = "
    17.          << *(int*)intStash.fetch(j)
    18.          << endl;
    19.   const int bufsize = 80;
    20.   Stash stringStash(sizeof(char) * bufsize);
    21.   ifstream in("Stash2Test.cpp");
    22.   assure(in, " Stash2Test.cpp");
    23.   string line;
    24.   while(getline(in, line))
    25.     stringStash.add((char*)line.c_str());
    26.   int k = 0;
    27.   char* cp;
    28.   while((cp = (char*)stringStash.fetch(k++))!=0)
    29.     cout << "stringStash.fetch(" << k << ") = "
    30.          << cp << endl;
    31. } ///:~
    32.  
    33.  
    34. Stack with constructors & destructors
    35.  
    36. //: C06:Stack3.h
    37. // With constructors/destructors
    38. #ifndef STACK3_H
    39. #define STACK3_H
    40.  
    41. class Stack {
    42.   struct Link {
    43.     void* data;
    44.     Link* next;
    45.     Link(void* dat, Link* nxt);
    46.     ~Link();
    47.   }* head;
    48. public:
    49.   Stack();
    50.   ~Stack();
    51.   void push(void* dat);
    52.   void* peek();
    53.   void* pop();
    54. };
    55. #endif // STACK3_H ///:~

    C++ Code:
    1. Stack không chỉ có một hàm tạo và hàm hủy mà còn có thể chồng các lớp vào nhau
    2. //: C06:Stack3.cpp {O}
    3. // Constructors/destructors
    4. #include "Stack3.h"
    5. #include "../require.h"
    6. using namespace std;
    7.  
    8. Stack::Link::Link(void* dat, Link* nxt) {
    9.   data = dat;
    10.   next = nxt;
    11. }
    12.  
    13. Stack::Link::~Link() {
    14.   delete data;
    15. }
    16. Stack::Stack() { head = 0; }
    17.  
    18. void Stack::push(void* dat) {
    19.   head = new Link(dat,head);
    20. }
    21.  
    22. void* Stack::peek() { return head->data; }
    23.  
    24. void* Stack::pop() {
    25.   if(head == 0) return 0;
    26.   void* result = head->data;
    27.   Link* oldHead = head;
    28.   head = head->next;
    29.   delete oldHead;
    30.   return result;
    31. }
    32.  
    33. Stack::~Stack() {
    34.   Link* cursor = head;
    35.   while(head) {
    36.     cursor = cursor->next;
    37.     delete head;
    38.     head = cursor;
    39.   }
    40.   head = 0; // Officially empty
    41. } ///:~
    C++ Code:
    1. //: C06:Stack3Test.cpp
    2. //{L} Stack3
    3. // Constructors/destructors
    4. #include "Stack3.h"
    5. #include "../require.h"
    6. #include <fstream>
    7. #include <iostream>
    8. #include <string>
    9. using namespace std;
    10.  
    11. int main(int argc, char* argv[]) {
    12.   requireArgs(argc, 1); // File name is argument
    13.   ifstream in(argv[1]);
    14.   assure(in, argv[1]);
    15.   Stack textlines;
    16.   string line;
    17.   // Read file and store lines in the stack:
    18.   while(getline(in, line))
    19.     textlines.push(new string(line));
    20.   // Pop the lines from the stack and print them:
    21.   string* s;
    22.   while((s = (string*)textlines.pop()) != 0) {
    23.     cout << s << endl;
    24.     delete s;
    25.   }
    26. } ///:~
    Hàm tạo và hàm hủy được tự động gọi đến, cho nên người sử dụng lớp có thể tập trung thao tác với đối tượng mà không lo lắng về việc nó đã được khởi tạo và hủy như thế nào.
    Đã được chỉnh sửa lần cuối bởi rox_rook : 06-04-2008 lúc 07:36 PM.

  6. #6
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Mặc định thắc mắc về code c++

    Tui cảnh cáo cậu lần chót, đọc nội qui bỏ code vào thẻ. Vì đây là sách mà tui rất thích nên tui không nỡ xóa hết code của cậu. Còn 1 lần nữa là tui del topic luôn nghe cậu !
    - Cậu học C++ được bao lâu rồi, nếu dưới 3 tháng thì tui nghĩ cậu quên việc hiểu hết trong 1 ngày đi. Vì tui có giải thích cậu cũng không thể hiểu hết 1 lần được. Post những đoạn nhỏ nêu ra những cái cậu đã học và không hiểu tui sẽ giải thích, còn nếu post 1 đống như thế 1 lần nữa tui sẽ cho bài cậu vào thùng rác ngay !

  7. #7
    Ngày gia nhập
    04 2008
    Bài viết
    0

    HIC BÁC NGUÔI NÀO !!!DOẠN NÀY NÓI VỀ Storage Allocation BÁC CÓ THỂ GIẢI THÍCH Í CỦA NÓ VÀ DOAN CODE CUA NO LA GI KO A.EM LA THANH VIEN MOI NEN HOI GA MONG BAC THONG CAM
    Code:
    //: C06:Nojump.cpp//C06 LA???
    // Can't jump past constructors
    
    class X {
    public:
    X();
    };
    
    X::X() {}
    
    void f(int i) {
    if(i < 10) {
    //! goto jump1; // Error: goto bypasses init//SAO CHO NAY LAI SAI HA BAC???
    }
    X x1; // Constructor called here
    jump1:
    switch(i) {
    case 1 :
    X x2; // Constructor called here
    break;
    //! case 2 : // Error: case bypasses init//???LẠI SAI
    X x3; // Constructor called here
    break;
    }
    } 
    
    int main() {
    f(9);
    f(11);
    }///:~

  8. #8
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Đó là lỗi nhảy qua những điểm liên tục trong chuơng trình và đoạn đó dùng để nêu ra sự nghèo nàn trong việc dùng goto và switch, vì khi đối tượng được tạo ra. Giả sử nếu if điều kiện thỏa và điều kiện của switch thỏa, compiler nó vẫn kiểm tra xem có đối tượng nào đã đang được khởi tạo hay chưa. Và dù nó không thỏa điều kiện thì constructor cho đối tượng x2 vẫn được gọi, cũng như x1.
    Đã được chỉnh sửa lần cuối bởi rox_rook : 06-04-2008 lúc 08:09 PM.

  9. #9
    Ngày gia nhập
    04 2008
    Bài viết
    0

    THANK BÁC NHIỀU VẬY XIN BÁC CHO EM BIT STASH O DAY DC SU DUNG LA TEN HAM HAY LA GÌ AH.VA Stash2.cpp VA Stash2.h KHÁC NHAU O CHO NAO AH

  10. #10
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Nếu cậu không phân biêt được cả file .h và cpp thì tui thành thật khuyên cậu khỏi đọc nữa cho khổ. Đây là sách không phải cho beginner, cái này là intermediate. Trường nào mà dạy quái lạ thế này, bắt 1 thằng học ktế mà đi đọc code này thì tui cũng thua...
    Stash2.cpp là tách ra để dễ quản lý : bao gồm các hàm thành viên.
    Stash2.h : dữ liệu, prototype của các hàm thành viên.
    Nói thật tui thực sự thấy tui quá rảnh khi ngồi giải thích với 1 người hoàn toàn mù về lập trình như cậu, có lẽ vì đây là cuốn sách có nhiều kỉ niệm với tôi nên tôi thực sự không nở nhìn nó mà làm ngơ, nhưng thôi cậu ráng mà tìm cách khác, vì 1 lần nữa tui phải nhắc lại : cậu không thể hiểu được những đoạn code trên nếu cậu chưa thực sự học qua C++.

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

  1. Lập trình C++ Xin Code Bài Toán Xếp Lịch Thể Thao
    Gửi bởi devilkiss12 trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 1
    Bài viết cuối: 03-12-2013, 01:06 AM
  2. Bài tập C Thắc mắc về đoạn code
    Gửi bởi phantom0610 trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 3
    Bài viết cuối: 03-01-2013, 08:18 AM
  3. Algorithm Chèn C++ code vào C# code như thế nào?
    Gửi bởi datinh_o0o7 trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 5
    Bài viết cuối: 14-03-2012, 11:46 AM
  4. Sau khi inject code làm thế nào để chèn code.
    Gửi bởi theboy909 trong diễn đàn Thắc mắc lập trình Visual C++
    Trả lời: 1
    Bài viết cuối: 16-10-2011, 12:34 PM
  5. Làm thế nào để dich một code có sẵn mà không cần code lại?
    Gửi bởi thuhuong888 trong diễn đàn Thắc mắc chung
    Trả lời: 1
    Bài viết cuối: 11-04-2009, 11:39 AM

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