009 C++的原始指针(Raw Pointer)

                                
                                    

                            
1
                            
T* ptr;        // 指向类型T的指针
                        

                            
2
                            
const T* ptr;  // 指向const T的指针
                        

                            
3
                            
T* const ptr;  // const指针(不可修改地址)
                        
                                
                            

                                
                                    

                            
1
                            
int value = 42;
                        

                            
2
                            
int* ptr = &value;  // 取地址
                        

                            
3
                            
*ptr = 100;         // 解引用并修改
                        
                                
                            

                                
                                    

                            
1
                            
int arr[5] = {1,2,3,4,5};
                        

                            
2
                            
int* p = arr;
                        

                            
3
                            
p++;    // 指向arr[1]
                        

                            
4
                            
p += 2; // 指向arr[3]
                        
                                
                            

                                
                                    

                            
1
                            
if (ptr1 == ptr2) {...}
                        

                            
2
                            
if (ptr != nullptr) {...}
                        
                                
                            

                                
                                    

                            
1
                            
int arr[3] = {1,2,3};
                        

                            
2
                            
int* p = arr;  // 数组名退化为指针
                        
                                
                            

                                
                                    

                            
1
                            
for (int* p = arr; p != arr + 3; ++p) {
                        

                            
2
                            
    std::cout << *p << " ";
                        

                            
3
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
int value = 42;
                        

                            
2
                            
int* p = &value;
                        

                            
3
                            
int** pp = &p;   // 二级指针
                        

                            
4
                            
int*** ppp = &pp; // 三级指针
                        
                                
                            

                                
                                    

                            
1
                            
const int* p1;    // 指向const int的指针
                        

                            
2
                            
int const* p2;    // 同上，等价写法
                        

                            
3
                            
int* const p3;    // const指针，指向int
                        

                            
4
                            
const int* const p4; // const指针，指向const int
                        
                                
                            

                                
                                    

                            
1
                            
const int* p1 = &value;
                        

                            
2
                            
int* p2 = const_cast<int*>(p1);  // 去除const限定
                        
                                
                            

                                
                                    

                            
1
                            
void modify(int* ptr) {
                        

                            
2
                            
    *ptr = 100;
                        

                            
3
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
int* create_array(size_t size) {
                        

                            
2
                            
    return new int[size];
                        

                            
3
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
void (*funcPtr)(int) = &myFunction;
                        

                            
2
                            
funcPtr(42);
                        
                                
                            

                                
                                    

                            
1
                            
int* p = new int(42);  // 单个对象
                        

                            
2
                            
delete p;
                        

                            
3
                            

                        

                            
4
                            
int* arr = new int[10]; // 数组
                        

                            
5
                            
delete[] arr;
                        
                                
                            

                                
                                    

                            
1
                            
int* p = (int*)malloc(sizeof(int));
                        

                            
2
                            
free(p);
                        
                                
                            

                                
                                    

                            
1
                            
if (ptr != nullptr) {
                        

                            
2
                            
    *ptr = value;
                        

                            
3
                            
}
                        

                            
4
                            

                        

                            
5
                            
// 使用RAII管理资源
                        

                            
6
                            
class PointerWrapper {
                        

                            
7
                            
    T* ptr;
                        

                            
8
                            
public:
                        

                            
9
                            
    explicit PointerWrapper(T* p) : ptr(p) {}
                        

                            
10
                            
    ~PointerWrapper() { delete ptr; }
                        

                            
11
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
void* vp = ...;
                        

                            
2
                            
int* ip = (int*)vp;
                        
                                
                            

                                
                                    

                            
1
                            
const int* cip = ...;
                        

                            
2
                            
int* ip = const_cast<int*>(cip);
                        

                            
3
                            

                        

                            
4
                            
Base* b = ...;
                        

                            
5
                            
Derived* d = dynamic_cast<Derived*>(b);
                        
                                
                            

                                
                                    

                            
1
                            
std::unique_ptr<int> up(new int(42));
                        

                            
2
                            
std::shared_ptr<int> sp = std::make_shared<int>(42);
                        
                                
                            

                                
                                    

                            
1
                            
void process(const std::string& str); // 优先使用const引用
                        
                                
                            

                                
                                    

                            
1
                            
std::vector<int> vec{1,2,3};
                        

                            
2
                            
std::span<int> sp(vec); // C++20
                        
                                
                            

                                
                                    

                            
1
                            
void* vp = ...;
                        

                            
2
                            
// 必须转换为具体类型后才能使用
                        
                                
                            

                                
                                    

                            
1
                            
using Handler = void(*)(int);
                        

                            
2
                            
Handler h = &myHandler;
                        
                                
                            

                                
                                    

                            
1
                            
struct S { int value; };
                        

                            
2
                            
int S::* ptr = &S::value;
                        

                            
3
                            
S s;
                        

                            
4
                            
s.*ptr = 42;
                        
                                
                            

                                
                                    

                            
1
                            
class Base { virtual void foo(); };
                        

                            
2
                            
class Derived : public Base {};
                        

                            
3
                            

                        

                            
4
                            
Base* b = new Derived();
                        

                            
5
                            
b->foo(); // 多态调用
                        

                            
6
                            
delete b;