Một câu hỏi nhỏ về type Char

[thuongshoo]

Không sao nhưng không đúng.

Cái kia là như thế này, chỉ là may mắn thôi. del a, nhưng chưa ghi đè gì vào *a, cũng chưa gán gì cho a, vậy nó vẫn trỏ vào vùng đó và chạy bình thường.
Nhưng bạn new một vài cái khác rồi ghi vào đó, quay lại in ra a xem, chắc là chết đấy.

Cho tui thử ví dụ nhe!
Tui chạy thử cái này nhưng vẫn 0 sao

#include <stdio.h>
#include <string>
#include <string.h>
using namespace std;
char *a,*b;
int main(){

char k[] = "Kiem tra thoi!";
a=new char [10];
strcpy(a,"anh");
delete [] a;
printf("%s\n",a);

b=new char [100];
strcpy(b,"Chchchchchchchchchchchchc");
printf("%s\n%s\n",a,b);

   return 0;
}

[thanggia]

Nó chạy đúng là ăn may thôi, tùy chương tình dịch, option và tình trạng máy lúc chạy.

May ở chỗ là delete(a) nó không gán a=null mà chỉ giải phóng vùng nhỡ đã cấp phát cho a. Như vậy, nếu không ghi gì vào đó thì dữ liệu trong a vẫn còn nguyên. delete(a) chỉ tạo điều kiện đề lệnh new tiếp theo có thể dùng vùng đó. Tùy, nếu máy dùng đến ùng nhớ đó thì sau del vẫn in được. Nhưng del cho phép mã lệnh sau dùng vùng nhớ đó nên không biết lúc nào dữ liệu bị mài đi.

Đấy là những điều sai, nó ăn may thì kệ nó nhưng tuyệt đối không được dùng.

Còn đây là kết quả tôi chạy

@¡y2@¡y2
Chchchchchchchchchchchchc
Chchchchchchchchchchchchc

ở đây, bạn delete [] a; sau lệnh này dữ liệu hỏng đi đi chứ không gán a=null, nên xuất hiện chuỗi rác ở đầu.

Còn đoạn sau, b được cấp phát đúng vào a, nên b==a.

Nếu sửa như sau thì theo dõi được ngay, không thì chạy step over

//---------------------------------------------------------------------------

#pragma hdrstop
#include <stdio.h>
#include <string>
#include <string.h>
#include <conio.h>

using namespace std;
char *a,*b;

//---------------------------------------------------------------------------

#pragma argsused
int main(int argc, char* argv[])
{
char k[] = "Kiem tra thoi!";
printf("truoc new pointer a: %p\n",a);
a=new char [10];
strcpy(a,"anh");
printf("truoc del chuoi a: %s pointer a %p\n",a,a);
delete  a;
printf("sau  del  chuoi a: %s pointer a %p\n",a,a);

b=new char [100];
strcpy(b,"Chchchchchchchchchchchchc");
printf("co b  chuoi a: %s pointer a %p\n",a,a);
printf("co b  chuoi b: %s pointer b %p\n",b,b);

getch();
   return 0;
}

Kết quả đây:

truoc new pointer a 00000000 //null
truoc del chuoi a: anh pointer a 00843DAC 
sau  del  chuoi a: @¡y2@¡y2 pointer a 00843DAC
co b  chuoi a: Chchchchchchchchchchchchc pointer a 00843DAC
co b  chuoi b: Chchchchchchchchchchchchc pointer b 00843DAC

[thuongshoo]

Để tui tóm ý lại coi có đúng hôn nghen
-lệnh delete agiải phóng vùng nhớ mà a đang trỏ đến. Còn giá trị của biến a là vẫn như cũ. Nếu vùng nhớ mới được giải phóng vẫn còn được chương trình sử dụng thì mình ra 0 sao.
- còn delete[] a thì ngược lại, dữ liệu bị hỏng đi và a vẫn như cũ. Bởi vậy nếu print a thì sẽ có rác.

Tui chạy delete a[], delete a thì kết quả vẫn giống nhau: hoàn toàn 0 sao.

Còn đoạn sau, b được cấp phát đúng vào a, nên b==a.

Trên máy tui, làm kiểu sao đi nữa, b vẫn khác a.
Hình như do thanggia xài Borland C 2006, còn tui xài MingW(GCC GNU) chăng?
anh thanggia
Nếu tui gán a=0xFFF thì in sẽ có lỗi.

#pragma hdrstop
#include <stdio.h>
#include <string>
#include <string.h>
#include <conio.h>
using namespace std;
char *a,*b;
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char k[] = "Kiem tra thoi!";
printf("truoc new pointer a: %p\n",a);
a=new char [10];
strcpy(a,"anh");
printf("truoc del chuoi a: %s .Pointer a %p\n",a,a);
delete[]  a;
printf("sau  del  chuoi a: %s .Pointer a %p\n",a,a);

b=new char [100];
strcpy(b,"Chchchchchchchchchchchchc");
printf("co b  chuoi a: %s .Pointer a %p\n",a,a);
printf("co b  chuoi b: %s .Pointer b %p\n",b,b);
   return 0;
}

[thanggia]

Để tui tóm ý lại coi có đúng hôn nghen
-lệnh delete agiải phóng vùng nhớ mà a đang trỏ đến. Còn giá trị của biến a là vẫn như cũ. Nếu vùng nhớ mới được giải phóng vẫn còn được chương trình sử dụng thì mình ra 0 sao.
- còn delete[] a thì ngược lại, dữ liệu bị hỏng đi và a vẫn như cũ. Bởi vậy nếu print a thì sẽ có rác.

Tui chạy delete a[], delete a thì kết quả vẫn giống nhau: hoàn toàn 0 sao.
Trên máy tui, làm kiểu sao đi nữa, b vẫn khác a.
Hình như do thanggia xài Borland C 2006, còn tui xài MingW(GCC GNU) chăng?
anh thanggia
Nếu tui gán a=0xFFF thì in sẽ có lỗi.

#pragma hdrstop
#include <stdio.h>
#include <string>
#include <string.h>
#include <conio.h>
using namespace std;
char *a,*b;
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
char k[] = "Kiem tra thoi!";
printf("truoc new pointer a: %p\n",a);
a=new char [10];
strcpy(a,"anh");
printf("truoc del chuoi a: %s .Pointer a %p\n",a,a);
delete[]  a;
printf("sau  del  chuoi a: %s .Pointer a %p\n",a,a);

b=new char [100];
strcpy(b,"Chchchchchchchchchchchchc");
printf("co b  chuoi a: %s .Pointer a %p\n",a,a);
printf("co b  chuoi b: %s .Pointer b %p\n",b,b);
   return 0;
}

Hài hước gớm nhỉ
delete [] a và delete a giống nhau. Bạn định nghĩa thế nào là "xóa dữ liệu" của mảng ???? xóa dữ liệu của string còn có thể là s="", chứ của mảng thì xóa thế nào được ????
nếu a và b khác nhau thì in ra khác nhau, a và b giống nhau thì in ra giống nhau. Có gì đâu.

Cái quan tâm là không bao giờ được dùng như thế.

[bete]

Tui đồng ý với bạn thanggia: con trỏ đã delete rồi thì không nên xài lại trước khi xin cấp phát lại

delete [] a và delete a giống nhau

=> đồng ý, đều giải phóng vùng nhớ đã cấp phát cho mảng a, nhưng có 1 điểm khác biệt là:
delete [] a: gọi destructor cho MỌI phần tử trong a
delete a: gọi destructor chỉ cho phần tử ĐẦU TIÊN trong a (a[0])

#include <iostream.h>

class A {
public:
  ~A() { cout << "~A" << endl; };
};

void main() {
  A *p1 = new A[3];
  cout << "start delete p1" << endl;
  delete p1;
  cout << "done delete p1" << endl;

  A *p2 = new A[3];
  cout << "start delete [] p2" << endl;
  delete [] p2;
  cout << "done delete [] p2" << endl;
}

=> in ra:

start delete p1
~A
a.out in free(): warning: modified (chunk-) pointer.
done delete p1
start delete [] p2
~A
~A
~A
done delete [] p2

(hiểu biết nông cạn; có gì sai sót mong được góp ý, xin cám ơn)

-thân

[whitepenguin]

Theo em thì thuongshoo ăn hên thôi

Cái toán tử delete và new thực chất theo em biết thì là 1 marco ,giống như ngày xưa hồi còn học Assembly làm gì có Instruction do CPU cung cầp mà cầp phát bộ nhớ gì đâu(cả bây giờ cũng không có) ,cái này là do mình làm riêng 1 segment nào đó ngoài khác DS, rồi mình dùng 1 biến trong chương trình để làm offset cho cái segment đó .Mỗi lần cấp phát thì + cái offset đó với số bytes cần cấp phát thôi , trước khi cộng thì nạp cái offset cho cái Pointer so với cái segment đó , khi xài thì tham chiếu kiểu ES:Pointer , vì mình có thể Move cái segment đó vào ES

Mỗi lần mình sử dụng 2 toán tử này thì 1 cái thông số nào đó nằm trong chương trình của mình dẽ được chỉnh sũa ,cái tác vụ quản lý bộ nhớ cấp phát bằng toán tử trên em nghĩ là do compiler dịch mã hết rồi ,mình không cần nửa
.Chứ thật ra chả có gì là hủy mảng hay con trỏ gì cả .
Em nghĩ chĩ được thế thôi

[sephiroth2m]

new và delete dựa vào API của HĐH để quản lý bộ nhớ. Trên Win32, mỗi tiến trình có 1 bảng quản lý các vùng nhớ đã được cấp phát hay chưa cấp phát. Mỗi khi new được gọi, bảng đánh dấu "đã cấp phát" cho vùng nhớ, khi delete được gọi, bảng lại đánh dấu "đã giải phóng" cho vùng nhớ đó.
Bạn có thể tham khảo: http://www.catch22.net/tuts/bigmem01.asp

[thanggia]

delete [] a: gọi destructor cho MỌI phần tử trong a
delete [] a: gọi destructor chỉ cho phần tử ĐẦU TIÊN trong a (a[0])

????????????????????????????????????????????????


bạn dịnh nghĩa thế nào là xóa một số ?????

tui đã nói, chuỗi có thể là chuỗi rỗng, số không thể là số rỗng, mảng không thể là mảng rỗng.

Đã không rỗng thì không xóa được

Hơi hài hước đấy.

[bete]

thân gửi bạn thanggia,

delete [] a: gọi destructor cho MỌI phần tử trong a
delete [] a: gọi destructor chỉ cho phần tử ĐẦU TIÊN trong a (a[0])
????????????????????????????????????????????????

=> cám ơn bạn đã chỉ ra chỗ sai => đã sửa thành:

delete [] a: gọi destructor cho MỌI phần tử trong a
delete a: gọi destructor chỉ cho phần tử ĐẦU TIÊN trong a (a[0])

-thân

[can_qua]

Nếu bạn dùng các built-in type như là char, int, long, v.v... thì delete hay là delete [] cũng không khác biệt gì nhau. Dùng vô tư đi.

char* pCh = new char[64];
delete [] pCh;

pCh = new char[64];
delete pCh;

delete kiểu gì thì bô nhớ cũng được thu hồi.