C語言 字元char與字串 差異與詳解

tags: C++ Concept2

初學C語言的時候遇到字串總是感到莫名其妙與不知道該怎麼用，比如說為什麼字串不能直接接上，或直接相等置換等等問題，大致列舉了一些常見的錯誤與解法。

常見的困惑

容易誤會的點，把字串當作型態，實際上字串是字元的陣列

int arr[3], arr2[3];
arr1 = arr2;

陣列的指派是不可行的，卻很容易把字串的指派，當作是可行的踩了坑

char* s="123\0";
char s2[4];

s2=s;

字串的指派是不可行的，不過反過來 s=s2 倒是可以。
還有一個很有趣的題型

char s[]="123\0";
printf("%s\n", s);
printf("%s\n", &s);

他們居然打印出一樣的結果！待會還是會提到，下面就開始提提有哪些該注意的地方，這都是指針與陣列的誤區。

指標與陣列的關係與差異

隱式轉換

陣列是陣列、指標是指標

只不過在大多數的時候陣列會自動轉換成指標，操作起來就像個指標一樣。具體差異在哪裡，並不太容易敘述清楚，下面會簡單的舉個例子說明不可互相替代。

指標宣告與陣列宣告

一般來說常數是存在唯讀記憶體內，比如說一個副程式的呼叫
“ABC\0” 返回的型態是 char* 一個指向 "ABC\0"的A 的地址

fun("ABC\0");

那個”ABC”不能夠被更動，是帶const屬性的，宣告的時候也一樣
這裡可以視為把 char* 賦值給 char* 是可執行的

char* str="ABC\0";

這樣子的方式會建立暫存，並返回指標，讓str指向那個暫存的唯讀空間
所以當你嘗試修改他時，是非法的。

str[0]='0';

如果我們使用字串的話則會不同的情況發生

char str[] = "123\0";

創建一個陣列，並將其內容初始化，這種情況下我們才可以正常的存取，從這裡可以看出來，除非你很確定我不會動到他，否則還是盡量使用

char str[];

避免自己採坑了，設定成指標之後不小心修改到發生非法存取

指標與陣列的差異也可以從sizeof上看出區別

int* num;
int arr[3];
printf("%d\n", (int)sizeof(num)); // 64bit size 8
printf("%d\n", (int)sizeof(arr)); // size 4*3=12

一個陣列可以獲取實際長度，轉為指標後則不可獲取

sizeof(arr) / sizeof(arr[0])

陣列的地址

經過以上大致敘述了陣列與指針的差異的，其中還有一個就是陣列也是可以取址的！

回頭來看看剛剛那一題，或許你已經想到是怎麼回事了

char s[]="123\0";
printf("%s\n", s);
printf("%s\n", &s);

這裡第一個 s 返回的是陣列起始的位址，型態為char*，這裡會發生一次隱式轉型，編譯器自作主張的將陣列char(*)[4]轉為指針char*型態；

第二個 &s 指的是對一個陣列 char(*)[7] 取址，而它的地址恰好與陣列的起始位置相等，型態一樣是char(*)[4]。

printf 接收到兩個相等的位置，自然會打印出兩個一樣的結果。

另外要記住對一個位址取址是非法的。

為什麼不能直接相等傳遞

char str1[]="ABC\0";
char str2[]="DEF\0";
str1 = str2; //Error

就像整數陣列一樣沒辦法直接等號過去，很容易誤把字串當成是一種變數叫字串，實際上他是字元的陣列；換個方式寫你可能就有感覺了

int arr1[]={1, 2, 3};
int arr2[]={3, 2, 1};

arr1 = arr2; // Error

另外這裡也可以看出陣列與指標的不同之處

int  arr1[]={1, 2, 3};
int* p1 = NULL;
p1 = arr1; // is ok

只能利用for迴圈一個一個搬移過去

char* str1="ABC\0";
char  str2[4];

for (int i=0; i<4 ; ++i){
    str1[i]=str2[i];
}

printf("%s\n", str2);

你也可以使用內建的函式搬移

#include <stdio.h>
#include <string.h>

int main (){
  char str1[]="Sample string";
  char str2[40];
  char str3[40];
  strcpy (str2,str1);
  strcpy (str3,"copy successful");
  printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
  return 0;
}

為什麼不能用+的

同上原因，陣列也沒辦法直接用加的，除此之外還要注意一個問題，長度是否足夠容下相加後

char str1[]="ABC";
char str2[]="ABC";

上述的作法長度會是3+1，可是相加後他們會變成6+1，你必須有一個足夠長的陣列，比如說將第二個長度拉長兩倍；這裡的+1是結束符。

char str1[]="ABC";
char str2[7]="ABC";

str2[3] = str1[0]
str2[5] = str1[1]
str2[4] = str1[2]

字串的相接也有函式可以使用

strcat (str2, str1);

字串殘留上一次的字元、清空與初始化字串

比如說這樣的範例，試圖讓副函式操作字串

/*****************************************************************
Name : 
Date : 2017/04/08
By   : CharlotteHonG
Final: 2017/04/08
*****************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

void fun(char* str, char* str2){
    for(int i = 0; i < strlen(str2); ++i) {
        str[i]=str2[i];
    }
    printf("%s\n", str);
}
/*==============================================================*/
int main(int argc, char const *argv[]){
    char s[]="ABCDEF", s2[]="abc";
    fun(s, s2);
    return 0;
}
/*==============================================================*/

印出的結果是

abcDEF

通常這時候就會有人告訴你，你沒有將字串歸零！而我必須告你這只是表象，歸零可以解決這個問題，但是不是主因。

主因是不正確的操作字串

我把它定義為不正確操作字串而不是錯誤，需要理解一下這句話的意思以及差別這非常重要。

必須要知道的是自串一個很特別的地方在於，判斷他的長度或結束點實際上是以 '/0' 做判別的，每個字串的結尾都會有這個符號，可以通過簡單的方法檢測

char* str="ABC";

if(str[3] == '\0')
    printf("End\n");

補上正確的結束符號

void fun(char* str, char* str2){
    int len=strlen(str2);
    for(int i = 0; i < len; ++i) {
        str[i]=str2[i];
    } str[len]='\0';
    printf("%s\n", str);
}

是的單單只是補上 str[len]='\0'; 即可解決這個問題；

這才是解決問題的根本，歸零可能會造成太多效能的浪費。歸零我認為是好習慣，但是更重要的是正確的操作字串，所以這裡應該使用正確的操作字串而不是歸零。

由此也可以推斷有一點必須要小心，字串的長度必須是實際長度+1

char str[4]="ABC";

不容易發現的坑

宣告的缺失的結束符

有些編譯器這樣寫不會幫你補上 '\0' 以下寫法可能會導致各種問題，找不到結束字元，讀到一堆垃圾值

char str[]="ABC";

手動補上結束字元可以處理這個問題

char str[4]="ABC\0";

這個問題大概只會出現在古老的編譯器上，知道就好，遇到的時候再乖乖補上。

複製時缺失的結束符

此外 string.h 內的複製函式 strncpy() 存在一樣問題，複製的長度如果不足到底，沒有複製完會導致結束符號沒有被複製到

char s[]="ABCDEF\0";
strncpy(s, "123", 3);
printf("%s\n", s); // s is "123DEF"

輸出的結果s會是 "123DEF" 這可能不是你要的結果，這是個不容易發現的坑；然後一個看似沒問的長度計算也是一個小坑。

char str[4]="ABC\0";
printf("len is %d", (int)strlen(str)); // len is 3

仍然會缺少束字元需自行補上+1的長度

char s[]="ABCDEF\0", s2[]="abc\0";
strncpy(s, s2, strlen(s2)+1);
printf("%s\n", s); // s is "abc"

越界存取

上面的+1又延伸出一個問題，小心加錯了會導致非法存取，看一下面的例子

char s[]="ABCDEF\0", s2[3]="abc";
strncpy(s, s2, strlen(s2)+1);
printf("%s\n", s); // s is "abc"

看起來好像都一樣，實際上那個

s2[3]="abc"

不存在結束符號之外，s2他的合法操作空間只有3。

strlen(s2)+1

返還的長度為3，再加上1為4，strncpy不會幫你檢查越界存取
把s與s2反過來也是，s2會被塞超過自己的長度

char s[]="ABCDEF\0", s2[3]="abc";
strncpy(s2, s, strlen(s)+1);

編譯不一定會出錯，但是已經是非法存取了，只是運氣好沒炸。

把一個字元轉為指針輸入 string.h 的函式

string.h 的函式多數都是輸入字串指針的，這裡必須區別字串的指針與字元的指針他們是不一樣的，字串的長度的是依靠'/0' 做判別，而一個字元裡面不存在結束符號。

編譯器可能會好心的在你的常數後面補上補上結束符號，即便你忘記輸入

char* str="ABC";

實際上可能為

char* str="ABC/0";

宣告陣列時

char str[3]="ABC";

實際上可能為

char str[4]="ABC/0";

可當你是一個字元時，他就是一個字元，你不能期待他能夠取出長度

char s='1';
char* p = &s;
strlen(p);

多數的string.h函式都是利用結束符號偵測長度，並會一起把結束符號複製進去

char str[10]="ABC/0";
char* str2="CBA/0";

strcat(str, str2);

利用結束符號找到 str 結尾，利用結束符號找到 str2 有多長複製幾次
如果你輸入的是字元，將可能會發生未定義行為，因為沒有結束符號

char str[10]="ABC/0";
char s='D';
char* p=&s;

strcat(str, &s); // 可能會發生非法存取

這一點不只在這個函式會出問題，其他函式也是一樣的。這裡的一個大坑就是 字串 跟 字元的指針 都是用同一個型態表示 char* ；但是他們的規格不一樣，字串要求要有結尾符號，字元的指標並不要求。很容易造成混亂。

可以使用 typedef 幫你區分兩者，不過這不是標準作法只是一個方式

typedef char* Str

接下來如果你需要表態為字串則使用 Str 需要表示字元指針則維持原方案。這部分要自己管理好代碼，因為 Str 也是兩者通用的，只是換個名字方便你區別。

char str[] = "ABC\0";
Str str2 = str;

char a='A';
char* p = a;
// Str p2 = a; // 可以編譯但這樣就沒意義，自己要管好

舉個例子

void fun(Str p){..}

當看到 Str 就應該自己想起那個規則，噢！不可以在這裡放入字元指針，要放入帶有結尾符號的字串；並且要知道這件事情只有你自己知道，編譯器不知道並不會發出提醒。

非必要不要自己造輪子

最後想提醒的一點是 char 的 sizeof() 是 1，比如說範例中有一個函式是複製字串，那種複製方法，一次最就複製1個，而你的CPU多數是是64位元，理論上最多可以一次複製64，該交給 strcpy() 還是要交給 strcpy()，要譯器廠商一定會很好的解決這些問題。

你應該要自己練習如何實作這些已有的函式
但是非萬不得以，否則不要在真正的專案上使用自己造的同功能函式。

​

C++ 副程式的 const左右值引用 的完美轉發

tags: C++ Concept2

四種不同屬性的函式

已知存在著四種屬性

• lvalue
• lvalue const
• rvalue
• rvalue const

他們分別呼叫的副程式參數長這個樣子

void fun(int & i){
    cout << "fun L" << endl;
}
void fun(int const & i){
    cout << "fun L const" << endl;
}
void fun(int && i){
    cout << "fun R" << endl;
}
void fun(int const && i){
    cout << "fun R const" << endl;
}

如此宣告我們可以統一使用 fun() 這個名稱呼叫四種不同的函式，分別是這樣呼叫

    int a=0;
    int const b=0;

    fun(a);
    fun(b);
    fun(move(a));
    fun(move(b));

函式轉發

如果你想要用另一個副程式來呼叫這個 fun() 藉此組合更多的功能可能會遇到一些問題

• const 與 non-const區分
• 左值與右值區分
• 右值進來有了名字變成左值

const 與非 const

可以試著重載const藉此可以同時引入兩種版本

template<class T>
void tran(T const & t){
    fun(t);
}

不過如此一來將導致你沒有辦法修改內容，也無從判斷原本是否是const
可以透過&&達到正確的結果

template<class T>
void tran(T && t){
    fun(t);
}

如此由 template 解決引數是否有 const，由 && 解決引數是左值還是右值。

消除名字

不過仍然有一個問題，參數本身是帶有名字的再引入的時候有了名字就變成左值
可以透過 forward<T>(t) 消除名字，獲取原本的屬性，
該是右值就還原右值，該是左值則保持左值

template<class T>
void tran(T && t){
    fun(forward<T>(t));
}

如此一來我們就可以好像換了一個別名似的，用第二個名字自由的操作，可以在函式內加上一些功能，增加代碼的重複性。

template<class T>
void tran(T && t){
    // 其他功能
    fun(forward<T>(t));
}

fun();
tran();

需要 fun() 時使用他，需要fun() 加上一額外的功能使用 tran() ，並可將重複的代寫在一起

為什麼不是使用 move() 語意即可?

確實可以透過move()協助我們呼叫右值引數的函式，但是無從得知原本的屬性是什麼，不管進入函式的是左值還是右值move()一律將其轉為右值；相較於forward()這個能夠還原原本的屬性，原本屬性是左值，出來就是還是左值。

如果要使用 move() 解決那至少也要存在著2個函式才可以解決，一個呼叫左值一個呼叫右值，這是因為無法得知原本屬性，只能給使用者自己判斷。

template<class T>
void tran1(T & t){
    fun(t);
}

template<class T>
void tran2(T && t){
    fun(move(t));
}

參考代碼

/*****************************************************************
Name : 
Date : 2017/04/07
By   : CharlotteHonG
Final: 2017/04/07
*****************************************************************/
#include <iostream>
using namespace std;

void fun(int & i){
    cout << "fun L" << endl;
}
void fun(int const & i){
    cout << "fun L const" << endl;
}
void fun(int && i){
    cout << "fun R" << endl;
}
void fun(int const && i){
    cout << "fun R const" << endl;
}

template<class T>
void tran(T && t){
    fun(forward<T>(t));
}
// template 解決了 const 與 non-constt 的問題，可以還原原本屬性
// && 解決了 LR 屬性問題，可以還原原本左右值屬性
// move提供使用者選擇，可以選擇要叫左值還是右值的函式
// forward 解決了引入的右值有了名字變成左值的問題
/*==============================================================*/
int main(int argc, char const *argv[]){
    int a=0;
    int const b=0;
    // fun(a);
    // fun(b);
    // fun(move(a));
    // fun(move(b));

    tran(a);
    tran(b);
    tran(move(a));
    tran(move(b));
    return 0;
}
/*==============================================================*/

​

c++ typeid() 用法 如何正確的顯示 變數型態名稱的亂碼、異常

typeid() 用法在不同的編譯器不一定有正確的結果顯示
可能會出現亂碼，或是無法辨識到底是什麼名稱

如果顯示異常需要一點技巧，主要的手段來自於

#include <typeinfo>
#include <cxxabi.h>

int status;
char *realname = abi::__cxa_demangle(typeid(obj).name(), 0, 0, &status);
std::cout << realname;
free(realname);

代碼要乾淨一點可以這樣封裝

/*****************************************************************
Name : 正確的顯示型態名稱
Date : 2017/04/04
By   : CharlotteHonG
Final: 2017/04/04

http://stackoverflow.com/questions/789402
*****************************************************************/
#include <iostream>
using namespace std;

#include <typeinfo>
#include <cxxabi.h>
class type_name{
public:
    template <class T>
    type_name(T const t): realname(
        abi::__cxa_demangle(typeid(T).name(), 0, 0, &status))
    {
        cout << realname << endl;
    }
    ~type_name(){
        free(realname);
    }
    int status;
    char *realname;
    #define type_name(i) type_name(std::move(i));
};
//================================================================
int main(int argc, char const *argv[]){
    type_name(1.0);
    type_name('a');
    type_name("a");

    void* i;
    type_name(i);

    class A{} a;
    type_name(a);
}
//================================================================

​