对C，C++宏进行代码分析（自上而下）

最新推荐文章于 2024-05-23 20:19:57 发布
最新推荐文章于 2024-05-23 20:19:57 发布
阅读量163 收藏
点赞数
分类专栏： C++ 词法分析 文章标签： c++ c语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42944928/article/details/128486056
版权

 宏定义：

  

    //#define _pi(var) (_cout <<#var<<_t(" = ")<<_tostr(var) << _t("\t"))
    //#define  _class class 
           
    //语法一:

    //#define 标识符 被标识符代表的字符串 //这种用法很简单,就是一种替换.

    //语法二 :

    //#define 标识符[(参数1,.....,参数n)] 被标识符代表的字符串 //其中,在"被标识符代表的

        字符串"中出现的形参将在使用时被实参替代. 就像写函数一样.

    //  补充一点 : 在用#define 定义时, 可以用斜杠("\") 续行.与vb中的下划线(" _")作用同. 

执行前：

 执行后：

 

 

 

else if (p[i] == _t('#'))
        { //这里开始分析C++宏定义语法
         
            //#ifndef  _MS_WINDOWS_       正确
            //# ifndef _MS_WINDOWS_  正确
            //#include<test.h">
            //# include <test.h> 正确
            // # + 预处理命令 + ？
            
            //着色预处理命令

            _string s1(_t(""), 50), s2(_t(""), 50), s3(_t(""), 50);
            
            int j = i + 1;
            int k = j;
           
            //跳过空格
            while (j < iTextLength) { if (p[j] == _t(' '))   ++j;   else   break; }
          
                    
            while (j < iTextLength){
                if (!gs.s_Syntax_IsWordSeparator(p[j])){
                    s1.add(p[j]);
                }else{
                    break;
                }
                ++j;
            }

            if (C_Preprocessor.indexOf(s1) != -1){ dtResult.Add(TextColor(i, j - i, Color_::Red)); }

            if (s1 == _t("define"))
            {
                //#define _pi(var) (_cout <<#var<<_t(" = ")<<_tostr(var) << _t("\t"))
                //#define  _class class 
           
                //语法一:

                //#define 标识符 被标识符代表的字符串 //这种用法很简单,就是一种替换.

                    //语法二 :

                //#define 标识符[(参数1,.....,参数n)] 被标识符代表的字符串 //其中,在"被标识符代表的字符串"中出现的形参将在使用时被实参替代. 就像写函数一样.

                //  补充一点 : 在用#define 定义时, 可以用斜杠("\") 续行.与vb中的下划线(" _")作用同.

                //检查有没有续行符
                bool bContinuation = false;

                //检查最后一位字符是不是续行符
                k = j;
                while (k < iTextLength)
                {
                    if (p[k] == _t('\n'))
                    { 
                        break;
                    }  
                    ++k; 
                }

                //宏定义续行
                if (p[k - 1] == '\\') { bContinuation = true; }


                //跳过空格
                while (j < iTextLength) { if (p[j] == _t(' '))   ++j;   else   break; }

                //拷贝第一部分
                while (j < iTextLength) {
                    if (p[j] != _t(' ')) {
                        s2.add(p[j]);
                    }
                    else {
                        break;
                    }
                    ++j;
                }


                if (s2.IndexOf(_t('(')) != -1) //函数格式
                {
                    //跳过空格
                    while (j < iTextLength) { if (p[j] == _t(' '))   ++j;   else   break; }
                    if (bContinuation)
                    {
                        //拷贝第二部分
                        ++k;
                        while (k < iTextLength && bContinuation)
                        {
                            if (p[k] == _t('\n'))
                            {
                                if (p[k - 1] != _t('\\'))
                                {
                                    bContinuation = false;
                                    break;
                                }
                            }

                            if (!bContinuation)break;
                            ++k;
                        }

                        for (int m = j; m < k; ++m)
                        {
                            if (p[m] != _t('\n') && p[m] != _t('\\'))
                                s3.add(p[m]);
                        }
                    }
                    else
                    {
                        //拷贝第二部分，拷贝到行尾
                        while (j < iTextLength) {
                            if (p[j] != _t('\n'))
                            {
                                s3.add(p[j]);
                            }
                            else
                            {
                                break;
                            }
                            ++j;
                        }
                    }
                   
                }
                else
                {
                    //跳过空格
                    while (j < iTextLength) { if (p[j] == _t(' '))   ++j;   else   break; }

                    
                    if (bContinuation)
                    {
                        //拷贝第二部分
                        ++k;
                        while (k < iTextLength && bContinuation)
                        {
                            if (p[k] == _t('\n'))
                            {
                                if (p[k - 1] != _t('\\'))
                                {
                                    bContinuation = false;
                                    break;
                                }
                            }                             

                            if (!bContinuation)break;
                            ++k;
                        }

                        for (int m = j; m < k; ++m)
                        {
                            if(p[m] != _t('\n') && p[m] != _t('\\'))
                                s3.add(p[m]);
                        }
                    }
                    else
                    {
                        //拷贝第二部分
                        while (j < iTextLength) {
                            if (p[j] != _t(' ') && p[j] != _t('\n'))
                            {
                                s3.add(p[j]);
                            }
                            else
                            {
                                break;
                            }
                            ++j;
                        }
                    }
   
                    sd.Define.Add(Pair<_string, _string>(s2, s3));
                    //#define _class class
                    if (s3 == _t("class") || s3 == _t("struct"))
                    {
                        sd.DefineClass.Add(s2);
                    }
                }


                //log::d(s2);
                //log::d(s3);
            }

完整代码：

/// <summary>
/// 一次性记录关键字，注释，字符串值，运算符，宏，括号配对,预处理命令的位置,并设置自定义数据颜色
/// </summary>
/// <param name="CustomData">生成自定义数据列表</param>
/// <returns></returns>
/// 创建时间： 2022-12-24      最后一次修改时间：2022-12-28
DList<TextColor> Syntax::GetTextColorPos_C(SyntaxData &sd)
{ 
    sd.Clear();  //清空原来的数据

    DList<TextColor> dtResult;

    //可见字符开始位置
    const _char* p = _code.c_str();

    //可见字符长度
    const int iTextLength = _code.length();

    if (iTextLength <= 0) return dtResult;
      
    _string sWord(_t(""), 50);  //50个_char缓冲

    Color_  cKeyWordColor = GetColor(SyntaxType::关键字);
    Color_  cExplanatoryNote = GetColor(SyntaxType::注释);
 
    Color_  cOS = GetColor(SyntaxType::运算符号);

    for (int i = 0; i < iTextLength; ++i)
    {
        if (p[i] == _t('/'))
        {
            ++i;

            if (i < iTextLength)
            {
                if (p[i] == _t('/')) //是"//"注释，查找注释结束位置 \n ，跳过注释
                {
                    int iStart = i - 1;
                    ++i;
                    bool bFind = false; //查找下一个 "\n"
                    while (i < iTextLength)
                    {
                        if (p[i] == '\n')
                        {
                            bFind = true;
                            break;
                        }
                        ++i;
                    }
                    if (!bFind)
                    {
                        return dtResult;
                    }
                    else
                    {
                        dtResult.Add(TextColor(iStart, i - iStart, cExplanatoryNote));
                    }
                }
                else if (p[i] == _t('*')) //是"/*"注释，查找注释结束位置 */ ，跳过注释
                {
                    int iStart = i - 1;

                    ++i;

                    bool bFind = false;
                    while (i + 1 < iTextLength ) //查找下一个 "*/"
                    {
                        if (p[i] == '*' && p[i + 1] == '/')
                        {
                            i += 1;
                            bFind = true;
                            break;
                        }
                        ++i;
                    }
                    if (!bFind)
                    {
                        return dtResult;
                    }
                    else
                    {
                        dtResult.Add(TextColor(iStart, i - iStart + 1, cExplanatoryNote));
                    }
                }
            }
            else
            {
                return dtResult;
            }
        }
        else if (p[i] == _t('\"')) {  //字符串开始

            if (i - 1 > 0 && p[i - 1] != _t('\\'))
            {
                int iStart = i;

                ++i;

                bool bFind = false; //查找下一个 "\""

                while (i < iTextLength )
                {
                    if (p[i] == '\"' && p[i - 1] != _t('\\'))
                    {                       
                        bFind = true;
                        break;
                    }
                    else if (p[i] == _t('\n')) //当前行已结束，还未找到引号配对
                    {                     
                        bFind = true;
                        break;
                    }

                    ++i;
                }
                if (!bFind)
                {
                    return dtResult;
                }
                else
                {
                    dtResult.Add(TextColor(iStart, i - iStart + 1, Color_::字符串));
                }
            }
            else
            {
                ++i;
            }
        }
        else if (p[i] == _t('\'')) { //字符开始

            if (i - 1 > 0 && p[i - 1] != _t('\\'))
            {
                int iStart = i;

                ++i;

                bool bFind = false; //查找下一个 "\'"

                while (i < iTextLength )
                {
                    if (p[i] == _t('\'') && p[i - 1] != _t('\\'))
                    {   
                        bFind = true;
                        break;
                    }
                    else if (p[i] == _t('\n')) //当前行已结束，还未找到引号配对
                    {
                        bFind = true;
                        break;
                    }

                    ++i;
                }
                if (!bFind)
                {
                    return dtResult;
                }
                else
                {
                    dtResult.Add(TextColor(iStart, i - iStart + 1, Color_::字符串));
                }
            }
            else
            {
                ++i;
            }
        }
        else if (Syntax::C_OperationalCharacter.IndexOf(p[i]) != -1)
        {
            dtResult.Add(TextColor(i, 1, cOS));
        }
        else if (p[i] == _t('{'))  //大括号查找全部文本
        {
            int iFlag = 0;

            for (int j = i + 1; j < iTextLength ; ++j)  //查找配对，直到遇到分号;
            {
                _char cRight = p[j];

                if (cRight == _t('}'))
                {
                    if (iFlag == 0)
                    {
                        Color_ c = Color_::RedRandom();
                        dtResult.Add(TextColor(i, 1, c));
                        dtResult.Add(TextColor(j, 1, c));
                        break;
                    }
                    --iFlag;
                }
                else if (cRight == _t('{'))
                {
                    ++iFlag;
                }
            }
        }
        else if ( p[i] == _t('['))
        {
            int iFlag = 0;
            for (int j = i + 1; j < iTextLength; ++j)  //查找配对，直到遇到分号;
            {
                _char cRight = p[j];

                if (cRight == _t(']'))
                {
                    if (iFlag == 0)
                    {
                        Color_ c = Color_::RedRandom();
                        dtResult.Add(TextColor(i, 1, c));
                        dtResult.Add(TextColor(j, 1, c));
                        break;
                    }
                    --iFlag;
                }
                else if (cRight == _t('['))
                {
                    ++iFlag;
                }
                else if (ga.c_IsPunctuation(cRight))  //遇到标点符号停止
                {
                    break;
                }
            }
        }
        else if (p[i] == _t('('))
        {

            int iFlag = 0;
            for (int j = i + 1; j < iTextLength; ++j)  //查找配对，直到遇到分号;
            {
                _char cRight = p[j];

                if (cRight == _t(')'))
                {
                    if (iFlag == 0)
                    {
                        Color_ c = Color_::RedRandom();
                        dtResult.Add(TextColor(i, 1, c));
                        dtResult.Add(TextColor(j, 1, c));
                        break;
                    }
                    --iFlag;
                }
                else if (cRight == _t('('))
                {
                    ++iFlag;
                }
                else if (cRight == _t(';'))
                {
                    break;
                }
            }

            //这里找出是否函数定义
            int j = i - 1;

            //去掉空格
            while (j > 0)
            {
                if (p[j] != _t(' ')) {   break; }
                --j;
            }

            _string sFun(_t(""), 50);
            while (j > 0)
            {
                if (!gs.s_Syntax_IsWordSeparator(p[j]))
                {
                    sFun.add(p[j]);
                }
                else
                {
                    break;
                }
                --j;
            }

           
            if (sFun.length() > 0)
            {
                sFun.Reversal();

                if (C_Keyword.indexOf(sFun) == -1) //不是关键字
                {
                    dtResult.Add(TextColor(j + 1, sFun.length(), Color_::函数));
                    //log::d(sFun);
                }
 
            }
     

        }
        else if (p[i] == _t('<')) //这里究竟是小于号还是尖括号
        {
            int iFlag = 0;

            for (int j = i + 1; j < iTextLength; ++j)  //查找配对，直到遇到分号;
            {
                _char cRight = p[j];

                if (cRight == _t('>'))
                {
                    if (iFlag == 0)
                    {
                        Color_ c = Color_::RedRandom();
                        dtResult.Add(TextColor(i, 1, c));
                        dtResult.Add(TextColor(j, 1, c));
                        break;
                    }
                    --iFlag;
                }
                else if (cRight == _t('<'))
                {
                    ++iFlag;
                }
                else if (cRight == _t(';'))
                {
                    break;
                }
            }

        }
        else if (p[i] == _t('#'))
        { //这里开始分析C++宏定义语法
         
            //#ifndef  _MS_WINDOWS_       正确
            //# ifndef _MS_WINDOWS_  正确
            //#include<test.h">
            //# include <test.h> 正确
            // # + 预处理命令 + ？
            
            //着色预处理命令

            _string s1(_t(""), 50), s2(_t(""), 50), s3(_t(""), 50);
            
            int j = i + 1;
            int k = j;
           
            //跳过空格
            while (j < iTextLength) { if (p[j] == _t(' '))   ++j;   else   break; }
          
                    
            while (j < iTextLength){
                if (!gs.s_Syntax_IsWordSeparator(p[j])){
                    s1.add(p[j]);
                }else{
                    break;
                }
                ++j;
            }

            if (C_Preprocessor.indexOf(s1) != -1){ dtResult.Add(TextColor(i, j - i, Color_::Red)); }

            if (s1 == _t("define"))
            {
                //#define _pi(var) (_cout <<#var<<_t(" = ")<<_tostr(var) << _t("\t"))
                //#define  _class class 
           
                //语法一:

                //#define 标识符 被标识符代表的字符串 //这种用法很简单,就是一种替换.

                    //语法二 :

                //#define 标识符[(参数1,.....,参数n)] 被标识符代表的字符串 //其中,在"被标识符代表的字符串"中出现的形参将在使用时被实参替代. 就像写函数一样.

                //  补充一点 : 在用#define 定义时, 可以用斜杠("\") 续行.与vb中的下划线(" _")作用同.



                //检查有没有续行符
                bool bContinuation = false;

                //检查最后一位字符是不是续行符
                k = j;
                while (k < iTextLength)
                {
                    if (p[k] == _t('\n'))
                    { 
                        break;
                    }  
                    ++k; 
                }

                //宏定义续行
                if (p[k - 1] == '\\') { bContinuation = true; }


                //跳过空格
                while (j < iTextLength) { if (p[j] == _t(' '))   ++j;   else   break; }

                //拷贝第一部分
                while (j < iTextLength) {
                    if (p[j] != _t(' ')) {
                        s2.add(p[j]);
                    }
                    else {
                        break;
                    }
                    ++j;
                }


                if (s2.IndexOf(_t('(')) != -1) //函数格式
                {
                    //跳过空格
                    while (j < iTextLength) { if (p[j] == _t(' '))   ++j;   else   break; }
                    if (bContinuation)
                    {
                        //拷贝第二部分
                        ++k;
                        while (k < iTextLength && bContinuation)
                        {
                            if (p[k] == _t('\n'))
                            {
                                if (p[k - 1] != _t('\\'))
                                {
                                    bContinuation = false;
                                    break;
                                }
                            }

                            if (!bContinuation)break;
                            ++k;
                        }

                        for (int m = j; m < k; ++m)
                        {
                            if (p[m] != _t('\n') && p[m] != _t('\\'))
                                s3.add(p[m]);
                        }
                    }
                    else
                    {
                        //拷贝第二部分，拷贝到行尾
                        while (j < iTextLength) {
                            if (p[j] != _t('\n'))
                            {
                                s3.add(p[j]);
                            }
                            else
                            {
                                break;
                            }
                            ++j;
                        }
                    }
                   
                }
                else
                {
                    //跳过空格
                    while (j < iTextLength) { if (p[j] == _t(' '))   ++j;   else   break; }

                    
                    if (bContinuation)
                    {
                        //拷贝第二部分
                        ++k;
                        while (k < iTextLength && bContinuation)
                        {
                            if (p[k] == _t('\n'))
                            {
                                if (p[k - 1] != _t('\\'))
                                {
                                    bContinuation = false;
                                    break;
                                }
                            }                             

                            if (!bContinuation)break;
                            ++k;
                        }

                        for (int m = j; m < k; ++m)
                        {
                            if(p[m] != _t('\n') && p[m] != _t('\\'))
                                s3.add(p[m]);
                        }
                    }
                    else
                    {
                        //拷贝第二部分
                        while (j < iTextLength) {
                            if (p[j] != _t(' ') && p[j] != _t('\n'))
                            {
                                s3.add(p[j]);
                            }
                            else
                            {
                                break;
                            }
                            ++j;
                        }
                    }
   
                    sd.Define.Add(Pair<_string, _string>(s2, s3));
                    //#define _class class
                    if (s3 == _t("class") || s3 == _t("struct"))
                    {
                        sd.DefineClass.Add(s2);
                    }
                }


                //log::d(s2);
                //log::d(s3);
            }
            

            //i = k;  //把 字符定位在#define 最后
            i = i + s1.length();
        }
       

        //开始查找，关键字，自定义类、等等

        if (gs.s_Syntax_IsWordSeparator(p[i]))
        {
            if (sWord.length() > 0)
            {           
                bool bFind = false;

            
                //自定义类
                DListNote<s_class>* pClass = sd.Class.First();

                while (pClass != null)
                {
                    if (pClass->Data.Name == sWord)
                    {
                        dtResult.Add(TextColor(i - sWord.length(), sWord.length(), Color_::自定义类));
                        //log::d(pClass->Data.Name);
                        bFind = true;
                        break;
                    }
                    pClass = pClass->Next;
                }
        
                //自定义函数
                DListNote<s_function> *pFun = sd.Function.First();

                while (pFun != null)
                {
                    if (pFun->Data.Name == sWord)
                    {
                        dtResult.Add(TextColor(i - sWord.length(), sWord.length(), Color_::自定义函数));
                        bFind = true;
                        break;
                    }
                    pFun = pFun->Next;
                }
   

                if(!bFind) //自定义类和函数不能是关键字
                { 
                    //关键字最小长度大于2，且全是小写字母
                    if (sWord.length() >= 2)
                    {
                        int n = sd.DefineClass.indexOf(sWord);
                        
                      
                        if ( sWord == _t("class") || sWord == _t("struct") || n != -1 ) //分析类定义，如果不在 #define 定义中
                        {
                            

                            //template<class T> T Max(T t1, T t2) { }
                            // template<class T1, class T2>  v
                            //class X { public : int i; };
                            //class A : public virtual X { public : int j ; };
                            //class B : public virtual X { public : double d; } ;
                            //class C : public A, public B { public : int k; };
                            //class D : public C {  };
                            //class Str : public Str<A>{};
                            //class
                            //bb{ };
                            //class CC : public std::string{}
                            //class cc{};
                            //template<class T> class Int{};    //先出现 > 

                            //typedef class MyClass* pMyClass;

                            //#define  _class class

                            //#define _class
                            // 
                            //class
                            // 
                            //_class dd{};
                            //

                            if (n == -1)
                            {
                              
                                dtResult.Add(TextColor(i - sWord.length(), sWord.length(), cKeyWordColor));
                            }
                            else
                            {
                              
                                dtResult.Add(TextColor(i - sWord.length(), sWord.length(), Color_::宏定义值));
                            }
                           
                            bool bDef = false;

                            //一定要 j = i - 1，否则可能跳到下一行内
                            //例：
                            //#define _string class
                            //
                            //...
                            for (int j = i - 1; j > 0; --j)
                            {
                                if (p[j] == _t('#'))
                                {
                                   
                                    bDef = true;
                                    break;
                                }

                                if (p[j] == _t('\n')) break;
                            }

                            if (!bDef)  //如果不是在宏义中
                            { 

                                bool bFind = false;
                                int j = i + 1;
                                int iCopyStart = -1;
                                int bCopyEnd = false;
                                _string sClassName(_t(""), 50);
                                while (j < iTextLength)
                                {

                                    //if (p[j] == _t(';')) break;      //typedef class MyClass* pMyClass;

                                    //比{ 和 : 先出现的 >  和 , 都是模板参数 或者 typedef
                                    if (p[j] == '>' || p[j] == _t(',') || p[j] == _t(';'))
                                    {
                                        break;
                                    }

                                    if (p[j] == _t('{') || p[j] == _t(':'))
                                    {
                                        bFind = true;
                                        break;
                                    }

                                    if (p[j] != _t(' ') && p[j] != _t('\t') && p[j] != _t('\n'))
                                    {
                                        if (iCopyStart == -1)  iCopyStart = j; //拷贝开始

                                        if (!bCopyEnd) sClassName.add(p[j]);
                                    }
                                    else
                                    {
                                        if (iCopyStart != -1) bCopyEnd = true; //拷贝结束，因为遇到了空格或 \t 或 \n
                                    }

                                    ++j;
                                }

                                if (bFind && iCopyStart != -1)
                                {
                                    s_class s;
                                    s.Name = sClassName;
                                    s.DefinitionPos = i + 1;                             

                                    dtResult.Add(TextColor(iCopyStart, sClassName.length(), Color_::自定义类));

                                    sd.Class.Add(s);  //添加自定义类                                     

                                    i = j;
                                }
                            }
                   
                        }
                        else
                        { 
                            if (C_Keyword.indexOf(sWord) != -1) //是关键字，记录位置
                            {
                                dtResult.Add(TextColor(i - sWord.length(), sWord.length(), cKeyWordColor));

                            }
                            else
                            {
                                //log::d(sWord);
                            }
                        }              
                  
                    }
                }           

                //log::d(_getc(sWord));

                sWord.Clear(); //清空
            }
        }
        else
        {
            sWord.add(p[i]);
        }
    }

    return dtResult;
}

碧海蓝天2022
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言c++游戏源代码大全
06-19
使用vs编译的二维小游戏，里面有很多小游戏和网站模板，比如超级玛丽、坦克大战、推箱子、别踩白块、贪吃蛇、种地浇水、盒子接球、连连看、军棋、五子棋、火车订票系统、图书馆借阅、涂格子游戏、火柴人游戏、大丰收...
python 宏分析脚本_如何解析C ++代码中的宏，使用CLANG作为解析器和Python作为脚本语言？...
weixin_39948277的博客
12-09 270
If I have the following macro in some C++ code:_Foo(arg1, arg2)I would like to use Python to find me all the instances and extents of that macro using Clang and the Python bindings provided with cinde...
C++宏实现的好的代码
chenglinhust的专栏
07-14 911
C++宏实现的好的代码 #include "errorcode_def.h" DEFINE_NUWA_ERRORCODE(RequestExecSuccess, 200, "NUWA_OK"); DEFINE_NUWA_ERRORCODE(ParameterInvalidExceptionError, 400, "ParameterInvalidException"); DEFINE_N
《C++面向对象程序设计》✍千处细节、万字总结（建议收藏）
热门推荐
像写诗一样优雅地写代码~
06-04 59万+
《C++面向对象程序设计》✍千处细节、万字总结 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++在非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联函数带有默认参数值的函数函数重载作用域标识符"::"强制类型转换new和delete运算符引用三、类和对象（一）3.1 类的构成3.2 成员函数的定义3.3 对象的定义和使用3.4 构造函数与析构函数构造函数成员初始化列表
C++归纳整理
xyq1212的博客
11-10 169
C++基础 内联函数 关键字inline 功能简单、规模较小且使用频繁的函数 在编译的时候将函数嵌入在调用它的地方，可以减少参数传递和控制转移等的开销 定义位于类声明中的函数会自动被认为内联函数 函数重载（多态） 在同一个作用域中，两个及以上函数的函数名相同，但是参数类型或者参数数量不同，编译器将根据参数类型和参数个数自动匹配并调用，这就是函数重载。 注意：编译器将类型引用和类型本身视为相同的参数。 类的成员函数可以重载，不同类的同名函数不是重载 extern “C” 实现C++调用C
实例代码分析c++动态分配
12-17
1. c语言中动态分配和释放 在c中，申请动态内存是使用malloc和free，这两个函数是c的标准库函数，分配内存使用的是系统调用，使用它们必须包含stdlib.h，才能编译通过。 malloc后需要检查内存是否分配成功，free则...
哈工大计算机系统大作业-C、C++底层分析代码.zip
06-29
本资料中包括本人关于哈工大计算机系统大作业中的C、C++底层实现分析这个实验所最终上交的代码，需要的可以看看
C++游戏源代码大全C语言C++游戏源代码大全
03-21
使用vs编译的二维小游戏，里面有很多小游戏和网站模板，比如超级玛丽、坦克大战、推箱子、 别踩白块、贪吃蛇、种地浇水、盒子接球、连连看、军棋、五子棋、火车订票系统、图书馆借阅 、涂格子游戏、火柴人游戏、大...
Visual C++源代码 192 如何使用自动化运行Excel宏
06-22
Visual C++源代码 192 如何使用自动化运行Excel宏Visual C++源代码 192 如何使用自动化运行Excel宏Visual C++源代码 192 如何使用自动化运行Excel宏Visual C++源代码 192 如何使用自动化运行Excel宏Visual C++源代码...
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 717
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
Python教程：使用Python和PyQt编写进制转换器工具
复现的博客
05-23 284
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
c++ const 的多种用途
05-17 155
常成员函数，不能修改对象的成员变量，也不能调用类中任何非 const 成员函数。该对象为常量对象，其中的任何成员都不能被修改，不能调用其他非const成员函数。const 在 * 左边。指针指向的值不可变，即 *p 不可修改。const 在 * 右边。指针本身不可变，即 p 不可修改。参数在函数内部不可改变。
C/C++免杀--原生态(GG)
金灰的博客
05-20 339
看个热闹吧... metasploit payload运行原理浅析(sockedi调用约定是什么) lib/msf/core/payload/windows/reverse_tcp.rb: metasploit-framework/lib/msf/core/payload/windows/reverse_tcp.rb at master · rapid7/metasploit-framework · GitHub 原生态: MSF: #include <Windows
c语言操作注意事项
dropLin的博客
05-20 194
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
C++质数的那些事（判断指数、区间筛质数、互质等等）
最新发布
A1063348628的博客
05-23 143
质数的定义：若一个正整数除了1和它自身之外不能被任何自然数整除，则该数称为质数，也叫素数。否则为合数。质数的性质：质数的分布较为稀疏，对于一个足够大的数S，不超过S的质数大约有个，也就是说每InN个数约有一个质数，代码： 二、筛出给定区间的质数 代码（欧拉筛（线性筛））： 三、判断两个整数是否互质 代码： 代码会随个人学习进行持续更新，谢谢您的观看！
C语言之函数指针（持续更新）
qq_47607743的博客
05-20 311
C语言指针
文件操作（C语言）
2303_76654613的博客
05-19 673
文件 = 文件内容 + 文件属性在程序设计中，文件分为程序文件和数据文件。
C++中的复合数据类型及高级特性概览
a_Loki的博客
05-23 203
C++作为一种面向对象的编程语言，提供了丰富的复合数据类型和高级特性，以增强代码的表达能力和效率。本文将概述结构体、联合体、枚举类型的基本概念，探讨函数重载的原则，解释重载解析的优先级，并简要介绍内联函数的作用及其优缺点。
自上而下的语法分析c++代码
05-05
在 C 代码中，一般采用递归下降分析器来实现自上而下的语法分析。下面是一个简单的 C 语言代码的自上而下语法分析实现： ``` #include #include #include char lookahead; // 当前读入的字符 // 词法分析器，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值