C++如何去除cpp文件的注釋詳解

更新時間：2022年09月30日 09:47:46 作者：「已注銷」

在日常工作中,我們會給c/c++代碼寫上一些注釋,但是往往為了保持最終的代碼盡可能小,我們需要刪除注釋,手動刪除太緩慢了,下面這篇文章主要給大家介紹了關(guān)于C++如何去除cpp文件注釋的相關(guān)資料,需要的朋友可以參考下

一、文件流

引入<fstream>頭文件，新建ifstream和ofstream對象，如果不能打開文件，則結(jié)束整個函數(shù)。

#include <iostream>
#include <fstream>
 
using namespace std;
 
bool stripComment(string infile,string outfile){
    ifstream ifs;
    ifs.open(infile,ios::in);
    if(!ifs.is_open()){
        cout<<"fail to read!"<<endl;
        return true;
    }
 
    ofstream ofs;
    ofs.open(outfile,ios::out|ios::trunc);//寫文件，如果已經(jīng)存在同名的文件，則刪除它創(chuàng)建新文件
    if(!ofs.is_open()){
        cout<<"fail to write!"<<endl;
        return true;
    }
 
    ifs.close();
    ofs.close();
 }
 
int main(int argc,char** argv){
    return 0;
}

二、具體邏輯

1.如何循環(huán)讀入字符

這是最關(guān)鍵的一步。我們利用ifstream對象的get()方法無條件地讀取文件流中的一個字符。什么叫無條件？這是與>>運算符相區(qū)分的，>>會自動跳過所有空白字符，也就是說，它讀不到空格、\t、\n，這不符合我們的需求。

同時，ifstream對象有一個putback()方法，它就是將一個字符重新放回文件流的末尾，下一次get()，我們還會讀到它：這有時候很有用。

get(char c) 會把文件流的末尾一個字符取出，放到char型變量c中。這個函數(shù)的返回值可以被轉(zhuǎn)換成一個布爾值，表示流的狀態(tài)：如果流狀態(tài)正常，則返回true；如果流狀態(tài)不正常（bad，fail，讀到文件尾符號），返回false。

char temp1{};
 while(ifs.get(temp1)){
    ofs<<temp1;
 }

最簡單的情況是，利用get()循環(huán)讀入字符并存入temp1變量中，再把temp1寫入新文件中。最終我們會得到與原文件一樣的副本。

2.處理單行和多行注釋

這兩種東西有同一個特點：都是以 / 開頭的。所以我們讀取到 / 這個字符時，就要小心一點：它是不是意味著我讀到了一個注釋？

我們可以在此基礎(chǔ)上再讀一個字符，存入另一個字符變量temp2中，看看它是什么情況：

/ ：一定讀到了一個單行注釋
* ：一定讀到了一個多行注釋
其他字符：剛剛讀到的 / 只是一個普通的正斜杠

對于第三種情況，我們這樣善后：

立刻輸出temp1（/）
把temp2放回文件流中等待下一次讀取，因為它可能有用（比如，是個雙引號）
跳轉(zhuǎn)到一開始的while循環(huán)

對于第一種情況：

一直向后讀字符，直到讀到一個換行符\n
將這個換行符放回文件流
跳轉(zhuǎn)到一開始的while循環(huán)

第二種情況最麻煩，我們必須找一個辦法確定什么時候多行注釋才能結(jié)束。C++的語法規(guī)定， /* 與最近的 */ 之間是多行注釋，那么我們只需找最近的 */ 即可。

while循環(huán)一直向后讀字符，直到找到一個 *
再讀一個字符，放入字符變量temp3中。
1. temp3是一個 / ，恭喜！我們已經(jīng)找到多行注釋的完整范圍，只要簡單地break掉當(dāng)前的while循環(huán)，再跳轉(zhuǎn)到開始的while循環(huán)就可以。不用輸出任何東西。
2. 不好，temp3不是 / ，這意味著我們沒有找到多行注釋的終止處。此時應(yīng)該將temp3放回文件流，返回步驟1：這是很必要的，如果temp3正好是一個* ，它之后恰好是一個 / 呢？我們不能丟棄任何“可能有用”的字符！

while(ifs.get(temp1)){
        //處理 "http://" 或 "/**/"
        if(temp1=='/'){
 
            checkStatus=true;
            ifs.get(temp2);//再讀一個字符
 
            if(temp2=='/'){//處理"http://"
 
                checkStatus=false;
                while(ifs.get(temp2)){//一直向后讀字符，直到讀到一個換行符\n
                    if(temp2=='\n') break;
                }
                ifs.putback('\n');//將換行符放回文件流
                continue;//跳轉(zhuǎn)到一開始的while循環(huán)
 
            }else if(temp2=='*'){//處理 "/**/"
 
                checkStatus=true;
                while(ifs.get(temp3)){
                    if(temp3=='*'){//找到一個*
                        ifs.get(temp4);
                        if(temp4=='/'){//找到一個/
                            checkStatus=false;
                            break;
                        }else{//沒找到/
                            ifs.putback(temp4);
                            continue;
                        }
                    }
                }
                continue;
            }else{//只讀到了一個 /
                checkStatus=false;
                ifs.putback(temp2);//把temp2放回文件流中等待下一次讀取
            }
        }
        ofs<<temp1;
    }

3.注意字符串

我們在2中的操作會破壞字符串中的一些內(nèi)容，比如：

處理前："asdf//gh/**/k"

處理后（//被當(dāng)成了單行注釋）："asdf

我們的需求是保留字符串原封不動輸出。

因此，當(dāng)temp1沒有讀到 / 時（即沒有進(jìn)入處理注釋的邏輯），temp1讀到了一個 " ，我們就要小心了：后面的內(nèi)容是字符串，原樣輸出即可。

立刻輸出temp1。
循環(huán)讀入后面的字符，存入temp2中，立即輸出temp2。
檢查剛剛輸出的temp2是不是 " ，如果是，結(jié)束當(dāng)前循環(huán)并跳轉(zhuǎn)到一開始的while循環(huán)

    while(ifs.get(temp1)){
        //處理 "http://" 或 "/**/"
        //省略...
 
        //處理字符串
        if(temp1=='\"'){
            ofs<<temp1;//立刻輸出第一個雙引號
            checkStatus=true;
            while(ifs.get(temp2)){
                ofs<<temp2;//立刻輸出temp2
 
                if(temp2=='\"'){//temp2是結(jié)尾的雙引號
                    checkStatus=false;
                    break;
                }
            }
        continue;//返回一開始的while循環(huán)
        }
        ofs<<temp1;
    }

4.注意轉(zhuǎn)義雙引號

以上的兩塊邏輯能解決一般問題，但在以下的例子中會出錯：

char c='\"';
const char* p1 = "sdjksd\"\\d//fj/*kdhjk\"dsfjl*/dks";

int main()
{
    cout << "http://The number of queens (4 -- 12) :// " ;
}

最后的結(jié)果是：

char c='\"';
const char* p1 = "sdjksd\"\\d//fj/*kdhjk\"dsfjl*/dks";

int main()
{
    cout << "
}

為什么呢？其實是轉(zhuǎn)義雙引號（\"）在作怪，因為我們目前的邏輯將轉(zhuǎn)義雙引號與表示字符串開頭與結(jié)尾的普通雙引號混為一談，導(dǎo)致字符串的邊界出現(xiàn)混亂。

以下紅色部分表示程序所認(rèn)為的字符串，藍(lán)色部分表示程序認(rèn)為是注釋的地方（）：

可以看出這個問題挺嚴(yán)重的，首要之急就是區(qū)分轉(zhuǎn)義雙引號和普通雙引號。

C++的文件流是逐個字符讀取的，也就是說，\" 在get()時，第一次會得到 \ ，第二次會得到 " 。

另一個有用的信息就是，C++的字符串邊界永遠(yuǎn)是普通雙引號，而不是轉(zhuǎn)義雙引號。

1>防止轉(zhuǎn)義雙引號作為字符串開頭

當(dāng)沒有進(jìn)入處理注釋的邏輯時，讀到了一個 \
立刻輸出 \ 本身
讀取下一個字符存入temp2中
立刻輸出temp2
跳轉(zhuǎn)到一開始的while循環(huán)

為什么這樣做呢？分析一下，因為 \ 與它后面的字符已經(jīng)被轉(zhuǎn)義（它們是一個整體），\ 后面的字符不能被認(rèn)為是代碼語法的一部分。比如：\ 之后的 " 不能被認(rèn)為是普通的雙引號，\ 之后的 / 也不能被認(rèn)為是一個代表注釋開頭的 /。反斜杠后面的字符從語法上來說應(yīng)該直接輸出。

注：處理注釋時不需這種邏輯，注釋里的 \ 沒有什么特殊的意義，和普通字符地位一樣。它不能影響后面那個字符的含義。

/*aaaaa\*/

仍然表示一個多行注釋

2>防止轉(zhuǎn)義雙引號作為字符串結(jié)尾

要在字符串的輸出邏輯中增加檢查機(jī)制。

剛剛輸出的字符(temp2)如果是一個 \
讀取下一個字符并直接輸出
繼續(xù)執(zhí)行當(dāng)前的while輸出循環(huán)，直到temp2是一個雙引號為止

    while(ifs.get(temp1)){
        //處理 "http://" 或 "/**/"
        //...省略
 
        //防止\"作為字符串開頭
        if(temp1=='\\'){
            checkStatus=true;
            ofs<<temp1;//直接輸出\
            //如果\后面有字符，直接輸出\后面的字符
            if(ifs.get(temp2)){
                ofs<<temp2;
                checkStatus=false;
            }
            continue;//跳轉(zhuǎn)到一開始的while循環(huán)
        }
 
        //處理字符串
        if(temp1=='\"'){
            ofs<<temp1;
            checkStatus=true;
            while(ifs.get(temp2)){
                ofs<<temp2;
 
                //如果剛剛輸出的是一個\
                if(temp2=='\\'){
                    if(ifs.get(temp3)) ofs<<temp3;//直接輸出后一個字符
                    continue;//繼續(xù)當(dāng)前的while循環(huán)
                }
 
                if(temp2=='\"'){//輸出了一個普通雙引號，表示字符串結(jié)束
                    checkStatus=false;
                    break;
                }
            }
        continue;
        }
        ofs<<temp1;
    }

5.增加簡單的查錯功能

當(dāng)我們發(fā)現(xiàn)了 /* 或 " 時，這意味著我們開始進(jìn)行注釋邊界的確定或字符串邊界的確定。當(dāng)發(fā)現(xiàn)了一個 \ 之后，\ 后面理應(yīng)有一個字符。

如果我們：

找到了 " 卻始終未找到對應(yīng)的 "
找到了 /* 卻始終沒有找到 */
找到了 \ 后面卻無字符

這三種情況意味著原文件的語法一定有問題，我們用一個變量checkStatus表示。當(dāng)開始進(jìn)行"尋找"過程，checkStatus被設(shè)為true。當(dāng)尋找結(jié)束后，變量的值被設(shè)為false。如果文件流結(jié)束，此變量依然為true，那么應(yīng)提醒用戶，文件的語法有問題。

完整代碼如下：

#include <iostream>
#include <fstream>
 
using namespace std;
 
bool stripComment(string infile,string outfile){
    ifstream ifs;
    ifs.open(infile,ios::in);
    if(!ifs.is_open()){
        cout<<"fail to read!"<<endl;
        return true;
    }
 
    ofstream ofs;
    ofs.open(outfile,ios::out|ios::trunc);
    if(!ofs.is_open()){
        cout<<"fail to write!"<<endl;
        return true;
    }
 
    bool checkStatus=false;
    char temp1{};
    char temp2{};
 
    char temp3{};
 
    while(ifs.get(temp1)){
 
 
        //handle "http://" OR "/**/"
        if(temp1=='/'){
 
            checkStatus=true;
            ifs.get(temp2);
 
 
            if(temp2=='/'){//handle "http://"
 
                checkStatus=false;
                while(ifs.get(temp2)){
                    if(temp2=='\n') break;
                }
                ifs.putback('\n');
                continue;
 
            }else if(temp2=='*'){//handle "/**/"
 
                checkStatus=true;
                while(ifs.get(temp2)){
                    if(temp2=='*'){
                        ifs.get(temp3);
                        if(temp3=='/'){
                            checkStatus=false;
                            break;
                        }else{
                            ifs.putback(temp3);
                            continue;
                        }
                    }
                }
                continue;
            }else{//only read a '/'
                checkStatus=false;
                ifs.putback(temp2);
            }
        }
 
        //handle possible '\"'
        if(temp1=='\\'){
            checkStatus=true;
            ofs<<temp1;
            //output char after '\'
            if(ifs.get(temp2)){
                ofs<<temp2;
                checkStatus=false;
            }
            continue;
        }
 
        //handle true ""
        if(temp1=='\"'){
            ofs<<temp1;
            checkStatus=true;
            while(ifs.get(temp2)){
                ofs<<temp2;
                //handle things after '\'
                if(temp2=='\\'){
                    if(ifs.get(temp3)) ofs<<temp3;
                    continue;
                }
                if(temp2=='\"'){
                    checkStatus=false;
                    break;
                }
            }
        continue;
        }
 
        ofs<<temp1;
 
    }
 
    ifs.close();
    ofs.close();
    return checkStatus;
}
 
int main(int argc,char** argv){
 
 
    if(argc!=3){//檢查是否輸入了兩個文件名
        cout<<"argument invalid!"<<endl;
        return -1;
    }
 
    bool res=stripComment(argv[1],argv[2]);//去除注釋
 
    if(res==true){//文件語法有錯
        cout<<"maybe wrong."<<endl;
    }
    return 0;
}

三、正則實現(xiàn)（Java）

這是題外話，但其實正則表達(dá)式也能實現(xiàn)這一功能。

由于C++的正則似乎不支持后發(fā)斷言，所以使用了Java的正則類。

主要思路：

讀取待去除注釋的文本，存入一個字符串中。
創(chuàng)建兩個正則表達(dá)式，一個匹配注釋和字符串，另一個只能匹配注釋。
對該字符串循環(huán)匹配第一個正則表達(dá)式，得到結(jié)果str。
若str符合第二個正則表達(dá)式，則記下str在原字符串中的起始下標(biāo)和結(jié)束下標(biāo)，將二者都存入ArrayList對象中。
匹配結(jié)束后，遍歷原字符串，如果字符下標(biāo)位于”存儲下來的注釋區(qū)域的起始和結(jié)束下標(biāo)“之間，就不輸出這些字符。

package project1100;
 
import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class mainTest {
    public static void main(String[] args) {
 
        String str2=
                "const char *qq=\"/**/\";\n" +
                "const char *pp=/**\"\\\"007*/\"/**/\";\n" +
                "const char *rr=/**'\\'007*/\"/**/\"\"http://\";";
        
        //匹配注釋和字符串
        Pattern pattern1=Pattern.compile("(/((/.*)|(\\*[\\S\\s]*?\\*/)))|((?<!\\\\)(\"([\\S\\s]*?)[^\\\\]\"))");
        //只能匹配注釋
        Pattern pattern2=Pattern.compile("(/((/.*)|(\\*[\\S\\s]*?\\*/)))");
        //用于存儲注釋區(qū)域下標(biāo)范圍的容器
        ArrayList<Integer> arrayList=new ArrayList<Integer>();
 
        Matcher matcher1=pattern1.matcher(str2);
 
        //匹配注釋和字符串
        while(matcher1.find()){
            //是注釋，下標(biāo)存入容器中
            if(pattern2.matcher(matcher1.group(0)).matches()) {
                arrayList.add(matcher1.start(0));
                arrayList.add(matcher1.end(0));
 
            }
        }
 
        //選擇輸出
        label:for(int i=0;i<str2.length();i++){
            for(int j=0;j<arrayList.size()/2;j++){
                if(i>=arrayList.get(j*2)&&i<arrayList.get(j*2+1)){
                    continue label;
                }
            }
            System.out.print(str2.charAt(i));
        }
        /*結(jié)果
            const char *qq="/**/";
            const char *pp="/**/";
            const char *rr="/**/""http://";
        */
    }
}

圖解：