#include <iostream.h>
#include <string.h>
void main()
{
/* test 1?
?const int c_ival = 0;
?int *pi;
?pi = c_ival;//指針變量可以通過一個常量賦值
?int ival = 2;//指針變量不可以通過一個變量賦值
?//pi = 2; //任何字面量，除0外，都不可以給指針變量賦值
?pi = 0; //指針只能通過字面值0或者const量0，以及NULL預定義變量賦值
?pi = NULL;//NULL是一個預處理變量，也可以為指針變量賦值。
*/
/* test 2
?double dval;
?double *pd = &dval;//可通過變量的地址(指針)給指針變量賦值
?double *pd2 = pd; //同類型的指針變量可以賦值
//?int *pi = pd;?? //不同類型的當然不能復制了
//?int *pi = &dval; //類型不同的變量的指針不能互相賦值
*/
/* test 3
?double obj = 3.14;
?double *pd = &obj;//OK,不多說
?void *pv = &obj;
?pv = pd;
?int *pi;
?//pi = &2;//不能對常量取地址。
?int iv = 11;
?pi = &iv;
?pv = pi;//類型相同的變量才可以賦值，而且void*型指針可以保持任何對象的地址
?//void*指針只能用于比較，傳參，不可以操作其指向的對象
*/
?/**
??友情提供：
??指針和引用的比較：
??雖然引用(reference)和指針都可以間接訪問另一個值，但它們之間有兩個主要的區別。
??第一個區別在于引用總是指向某個對象：定義引用時沒有初始化是錯誤的。第二個重要
??的區別則是賦值行為的差異：給引用賦值修改的是該引用所關聯的對象的值，而并不是
??使引用與另一個對象關聯。應用一經初始化，就始終指向同一個特定的對象。
?*/
/* test 4
?int ival = 1024, ival2 = 2048;
?int *pi = &ival, *pi2 = &ival2;
?pi = pi2;
//正確
?int &ri = ival, &ri2 = ival2;
?ri = ri2;
?cout<<"ri = "<<ri<<", ri2 = "<<ri2<<endl;
?//output :ri = 2048, ri2 = 2048
?//注意這里并沒有改變ri與ri2的指向，而是改變他們所各自關聯的對象的值。
*/
/* test 5
?int ival = 1024;
?int *pi = &ival;
?int **ppi = π //C++使用**操作符指派一個指針指向另一個指針。**也是指向符。
?//下面相同的值，相同的對象
?cout<<ival<<" "<<*pi<<" "<<**ppi<<endl;
*/
//忍不住了，討論下，const引用
?//正解：const引用是指向const對象的引用。
?//const int ival = 1024;?//引用必須初始化
?//const int &refVal = ival;
?//int &ref2 = ival;//非常量對象的引用不可以指向常量對象的引用
//?const int &refVal2 = 2;//const引用可以以字面量初始化
//?int vali = 1111;
//?const int &refVal3 = vali;//const引用可以以變量初始化，但是通過該引用訪問該變量，就只能當做常量使用。
//?refVal3 = 100; 不可修改，表明這里是該引用指向了一個常量對象。
?//l-value左值，左值是變量，可左可右。 r-value右值，右值是常量(包括字面量)，只能右
?/*
??在指針上加上(或減去)一個整形數值n等效于獲得一個新指針，該新指針指向指針原來指向的元素之后
??(或之前)的第n個元素。
??兩個指針減法操作的結果是標準庫類型ptrdiff_t的數據。這是一個signed整形，它表示兩個指針之間
??的差距。
?*/?????
/*?test 6
?const size_t arr_sz = 5;
?int int_arr[arr_sz] = {0, 1, 2, 3, 4};
?for(int *pbegin = int_arr, *pend = int_arr + arr_sz;
???pbegin != pend; ++pbegin)
???{
???//?cout<<int_arr[5]; 為什么會輸出5，詭異啊。
????cout<<*pbegin<<' ';
???}
*/
?//指向const對象的指針和const指針
?//指向const對象的指針這樣聲明 const double *cptr;
?//1. 不能修改所指對象的值，因為是const對象嘛。
?//*cptr = 42; //這是錯誤的。
?//2. 不能使用void*指針保持const對象的地址，而必須使用const void*。
//?const int universe = 42;
//?const void *cpv = &universe;
//?void *pv = &universe; //錯誤的，必須使用const void*
?//3. 對于非const對象的處理和const引用是一樣的。
?//但是我們可以修改指針變量的值，使我們的指針指向新的對象。只是這個對象無論是否為const
?//只要我們通過這個指針訪問，那么系統都認為其為const。(自以為指向const的指針)
?//const指針是這樣 double *const cptr;
?//指針變量的本身的值無法修改，也就是指針無法執行初始指定的對象的值，
?//這樣和const引用則比較像了,但是我們可以修改我們所執行的對象。
/*
?double dval = 33.33;
?double *const cptr = &dval;
?*cptr = 332.02;
?cout<<dval<<" "<<*cptr;
?//下面最變態的：指向const對象的const指針
?const double pi = 3.14159;
?const double *const pi_ptr = π
?//從右向左讀，關于指針都一般都這么讀，既不可以修改指針所指向的對象的值，也不可以修改該指針的指向。
*/
/*
?//typedef和指針 不多說反正記得typedef不是簡單的文本擴展，其實只要注意const應該寫在類型后面就可以了
?//所以：
?//下面
?typedef string *pstring;
?const pstring cstr;
?//等價于
?string *const cstr;//也就是const指針。
*/
}
?
再加一點，天亮了要睡覺了啊！
#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include <string>
using namespace std;
void main()
{
?const char *cp1 = "A string example";
?const char *cp2 = "A different string";
//?int i = strcmp(cp1, cp2);
//?printf("%d\n", i);
//?i = strcmp(cp2, cp1);
//?printf("%d\n", i);
//?i = strcmp(cp1, cp1);
//?printf("%d\n", i);
//?char largeStr[16 + 18 + 2];
//?strcpy(largeStr, cp1);
//?printf("%s\n", largeStr);
//?strcat(largeStr, " ");
//?strcat(largeStr, cp2);
//?printf("%s\n", largeStr);
//?char ca[] = {'C', '+', '+', '\0'};
//?cout<<strlen(ca)<<endl; 空格并不是null
?int ia[3][4] = {
??{0, 1, 2, 3},
??{4, 5, 6, 7},
??{8, 9, 10, 11},
?};
?typedef int int_array[4];
?int_array *ip = ia;
?for(int_array *p = ia; p != ia + 3; ++p)
??for(int *q = *p; q != *p + 4; ++q)
???cout<< *q <<endl;
?//可使用數組長度后面的一對圓括號，對數組元素做值初始化:
??int *pia2 = new int[10]();
?//?這里初始化為0
?// 允許定義類類型的const數組，但該類型必須提供默認的構造函數
?//?const string *pcs = new const string[100];//似乎不支持, 而且沒有必要，
??//因為string早已做好了相關的支持。
??//這里就會使用默認構造函數來初始化數組元素
??//使用delete [] 數組名 來釋放數組空間。
??//delete [] pcs;
??delete [] pia2;
}
?