Tham chiếu Java khác với con trỏ C như thế nào?

C có con trỏ và Java có cái được gọi là tài liệu tham khảo. Họ có một số điểm chung theo nghĩa là tất cả đều hướng đến một cái gì đó. Tôi biết rằng con trỏ trong C lưu trữ các địa chỉ mà chúng trỏ đến. Làm tài liệu tham khảo cũng lưu trữ địa chỉ? Làm thế nào chúng khác nhau ngoại trừ con trỏ linh hoạt hơn và dễ bị lỗi?

Tài liệu tham khảo có thể được thực hiện bằng cách lưu trữ địa chỉ. Thông thường các tham chiếu Java sẽ được triển khai như các con trỏ, nhưng điều đó không bắt buộc bởi đặc tả. Họ có thể đang sử dụng một lớp bổ sung bổ sung để cho phép thu gom rác dễ dàng hơn. Nhưng cuối cùng, nó sẽ (hầu như luôn luôn) sôi sục với các con trỏ (kiểu C) có liên quan đến việc thực hiện các tham chiếu (kiểu Java).

Bạn không thể làm số học con trỏ với các tài liệu tham khảo. Sự khác biệt quan trọng nhất giữa một con trỏ trong C và một tham chiếu trong Java là bạn thực sự không thể lấy (và thao tác) giá trị cơ bản của một tham chiếu trong Java. Nói cách khác: bạn không thể thực hiện số học con trỏ.

Trong C, bạn có thể thêm một cái gì đó vào một con trỏ (tức là địa chỉ) hoặc trừ thứ gì đó để trỏ đến những thứ "gần đó" hoặc trỏ đến các địa điểm ở bất kỳ nơi nào .

Trong Java, một tham chiếu chỉ đến một điều và chỉ điều đó. Bạn có thể làm cho một biến giữ một tham chiếu khác , nhưng bạn không thể yêu cầu nó chỉ ra "điều sau điều ban đầu".

Tài liệu tham khảo được đánh máy mạnh mẽ. Khác biệt nữa là các loại tài liệu tham khảo được nhiều kiểm soát chặt chẽ hơn trong Java so với loại một con trỏ trong C. Trong C bạn có thể có một int*và bỏ nó vào một char*và chỉ tái diễn dịch bộ nhớ tại địa điểm đó. Việc giải thích lại đó không hoạt động trong Java: bạn chỉ có thể diễn giải đối tượng ở đầu kia của tham chiếu như một cái gì đó đã có (tức là bạn chỉ có thể chuyển một Objecttham chiếu đến Stringtham chiếu nếu đối tượng được trỏ thực sự là a String).

Những khác biệt đó làm cho con trỏ C mạnh hơn, nhưng cũng nguy hiểm hơn. Cả hai khả năng đó (số học con trỏ và diễn giải lại các giá trị được trỏ đến) thêm tính linh hoạt cho C và là nguồn gốc của một số sức mạnh của ngôn ngữ. Nhưng chúng cũng là nguồn gây ra vấn đề lớn, bởi vì nếu sử dụng không đúng cách, chúng có thể dễ dàng phá vỡ các giả định rằng mã của bạn được xây dựng xung quanh. Và thật dễ dàng để sử dụng chúng không chính xác.

Tài liệu tham khảo C ++ lại khác.

Chúng phải được khởi tạo và không thể rỗng (ít nhất là không phải trong một chương trình được hình thành tốt) và không thể được nối lại để đề cập đến một cái gì đó khác. một tham chiếu C ++ giống như một bí danh cho một đối tượng.

Một sự khác biệt quan trọng khác giữa các con trỏ và các tham chiếu Java / C ++ là bạn có thể lấy địa chỉ của một con trỏ mà bạn không thể truy cập vào địa chỉ của một tham chiếu (thực sự không cần phải có một tham chiếu C ++ như một đối tượng trong bộ nhớ) con trỏ tới một con trỏ nhưng không phải là một tham chiếu đến một tham chiếu

Tài liệu tham khảo Java và con trỏ C khác nhau ở hai điểm chính xác:

1. Không có số học con trỏ cho trước đây.
2. Và bạn không thể tạo tham chiếu Java cho bất cứ điều gì bạn muốn, bạn chỉ có thể sao chép những tham chiếu đã lưu ở đâu đó (trường tĩnh, trường đối tượng, biến cục bộ) hoặc được trả về bởi các lệnh gọi hàm (như lệnh gọi hàm tạo), do đó tất cả đều tham chiếu đến Java đối tượng (không bao giờ để loại cơ bản như tài liệu tham khảo, char, intvà vân vân).

Ai đó đã viết rằng Tài liệu tham khảo được gõ mạnh, bởi vì bạn không thể buộc trình biên dịch coi int*là một char*.
Hoàn toàn ngoài thực tế là chuyển đổi cụ thể là thực sự an toàn , không có tính đa hình trong C, do đó so sánh là không bắt đầu.
Chắc chắn, Java được gõ mạnh hơn C, không phải là tính năng của con trỏ C so với tham chiếu Java, bạn cần sử dụng JNI để phá vỡ an toàn loại (ngoài việc bỏ qua các hạn chế chung), nhưng ngay cả trong C bạn cũng phải ép buộc trình biên dịch.

Có người viết rằng Java tài liệu tham khảo có thể được thực hiện như con trỏ C, mà tôi nói chắc chắn, vì họ là đúng ít mạnh mẽ, trên máy 32Bit họ thường là, nếu JVM được thực hiện trong C . Mặc dù trên các máy 64Bit, chúng thường được nén các con trỏ đối tượng thông thường ("OOPs nén") để tiết kiệm không gian và băng thông.
Dù sao, những con trỏ C đó cũng không cần tương đương với địa chỉ phần cứng, ngay cả khi chúng thường (> 99% triển khai) là vì lý do hiệu suất.
Cuối cùng, đó là một chi tiết triển khai không được đưa ra cho lập trình viên.

Họ hơi khác nhau. Trong Java, một bản sao của tham chiếu được sao chép vào ngăn xếp của một hàm được gọi, trỏ đến cùng một đối tượng như hàm gọi và cho phép bạn thao tác với đối tượng đó. Tuy nhiên, bạn không thể thay đổi đối tượng mà chức năng gọi tham chiếu.

Hãy xem xét mã java sau đây

public static void changeRValue(StringBuffer sb){
    sb = new StringBuffer("helllllo"); /*attempt to assign the reference
                                        to a new object*/
}
public static void main(String[] args) {
    StringBuffer sb = new StringBuffer("hi");     //Create a new string buffer
    changeRValue(sb);                             //Call changeRValue
    System.out.println(sb.toString());            //Prints "hi" not "hello"
}

Bây giờ hãy xem xét một con trỏ trong c ++:

void func(Dog* dog){
    *dog = Dog("hello world"); //Change the value of dog to a new object
}

int main(int argc, const char * argv[]) {
    Dog dog1("hi");                            //Create a dog object
    func(&dog1);                               //pass the address of dog
    cout << dog1.name;                         //Prints "hello world" not hi.
    return 0;
}