AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C++还在用printf/cout进行Debug？学习一下如何自己写日志库吧（上篇）

2022-03-02 899
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 日志是出现异常第一个想到的东西，它记录了程序运行过程中所调用的函数，所接受到的值，所执行的行为等等。大家也都看到这篇的标题了，我这个人有一个缺点，就是不太喜欢用别人的东西，如果有能力，我希望自己造，所以今天我们自己来动手撸一个日志库，文章重点讲实现过程，如果需要源码，可以前往github获取[FdogLog，一个轻量级C++日志库，用于日志服务。

@[TOC]

一. 前言

哈喽，自从实习以来很久没有更文了，一是没有时间，二是实习了之后突然发现自己能写的东西也没有多少了。赶上1024有征文活动，就写一篇吧，在实习的这段时间，我更加认识到日志的重要性，客户端值没传过来？看日志，服务崩溃了？看日志，没错，日志是出现异常第一个想到的东西，它记录了程序运行过程中所调用的函数，所接受到的值，所执行的行为等等。大家也都看到这篇的标题了，我这个人有一个缺点，就是不太喜欢用别人的东西，如果有能力，我希望自己造，所以今天我们自己来动手撸一个日志库，文章重点讲实现过程，如果需要源码，可以前往github获取FdogLog，一个轻量级C++日志库，用于日志服务。

==跪求三连！==

二. 基本功能

我们先来捋一捋这个日志库应该实现那些功能。

  1. 日志最最最基本的功能是什么，当然是打印或记录日志。
  2. 信息应该包括哪些信息，时间？运行用户？所在文件？想要显示的信息？（自定义显示信息下篇实现）
  3. 信息虽然显示丰富，但是要尽可能让代码自己获取其他信息，调用者只需要设置最主要的信息。
  4. 信息有重要等级之分，所以我们需要对信息做必要分类，提高效率。
  5. 如何实现全局尽可能简洁的调用。
  6. 如果日志库是运行在多线程环境，如何保证线程安全。（下篇实现）

这些就是一个日志库所具备的最基本的功能，接下来继续思考，还需要什么。

  1. 怎么控制日志的行为。
  2. 如果保存在文件，如何定义文件名。
  3. 随着日志增加，文件会越来越大，如何解决。（下篇实现）

简单规划完一个不那么完美的日志库所具备的能力，现在我们来对这几条做更详细的规划。

  1. 日志最最最基本的功能是什么，当然是打印或记录日志。
  2. 信息应该包括哪些信息，时间？运行用户？所在文件？想要显示的信息？

当我在调用一个名为function的函数时。

function();

你希望它输出怎么样的信息。

我被调用
[2021-10-20 23:27:23] 我被调用
[2021-10-20 23:27:23] INFO 我被调用
[2021-10-20 23:27:23] INFO root 我被调用
[2021-10-20 23:27:23] INFO root 17938 我被调用
[2021-10-20 23:27:23] INFO root 17938 [/media/rcl/FdogIM/service.h function:8] 我被调用

我想大部分人都会选择最后一种输出信息吧(虽然在这之前，我们都大量使用cout输出第一种)，所以我们的日志应该包括时间，日志等级，运行用户，进程ID，调用函数所在文件，以及调用时所在行数。当然总会有人不想全部输出，这将在后面给出方案。

  1. 信息虽然显示丰富，但是要尽可能让代码自己获取其他信息，调用者只需要设置最主要的信息。
  2. 信息有重要等级之分，所以我们需要对信息做必要分类，提高效率。
  3. 如何实现全局尽可能简洁的调用.

信息有重要等级之分，要可以对信息做区分，按照常见的等级之分，有：

ERROR： 此信息输出后，主体系统核心模块不能正常工作，需要修复才能正常工作。
WARN：   此信息输出后，系统一般模块存在问题，不影响系统运行。
INFO：     此信息输出后，主要是记录系统运行状态等关联信息。
DEBUG： 最细粒度的输出，除去上面各种情况后，你希望输出的相关信息，都可以在这里输出。
TRACE：  最细粒度的输出，除去上面各种情况后，你希望输出的相关信息，都可以在这里输出。

有了等级之分，如何实现全局尽可能简洁的调用，通俗的说就是去掉一切不必要的调用，只留下最主要的调用。

例如：

#include<iostream>
#include"fdoglogger.h"  //添加日志库头文件

using namespace fdog;   //日志库的命名空间

int main(){
    FdogError("错误");
    FdogWarn("警告");
    FdogInfo("信息");
    FdogDebug("调试");
    FdogTrace("追踪");
    return 0;
}

你不必初始化什么信息，调用什么多余的初始化函数，只需要用这五个类似函数的东西来输出即可，同样，如果是另一个源文件，依旧是这样的调用方式（这里可以使用单一模式来实现，其意图是保证一个类仅有一个实列，并提供一个访问它的全局访问点，该实例被所有程序模块共享。就比如日志的输出。）。

  1. 如果日志库是运行在多线程环境，如何保证线程安全。

到目前，一个基本的日志库的调用基本成形，如果在单线程，它可以很好的工作，但是到了多线程环境下，就不能保证了，第一点就是单例模式的创建，当两个线程同时去初始化时，无法保证单一实例被成功创建，第二，日志既然是输出到文件，不同线程写入文件时，如何保证写入数据不会错乱。既然写的是C++的日志输出，必然用到了cout ，cout 不是原子性的操作，所以在多线程下是不安全的，这些都是我们需要考虑到的。

  1. 怎么控制日志的行为。

这里使用配置文件进行日志的行为规定，包括打印什么日志，输入到文件，还是终端，输出的等级，以及日志开关，等等，配置文件将在程序启动时被读取。(提醒各位千万不要写死代码，后患无穷！！！)

  1. 如果保存在文件，如何定义文件名。
  2. 随着日志增加，文件会越来越大，如何解决。

日志的文件名由配置文件指定，但是创建时会在后面加上创建日期后缀，并且可以在配置文件中配置每隔多少天创建一个新的日志文件，如果配置中心有设置日志文件大小，则会优先大小判断，超过便创建一个新文件。

三. 代码实现

1. fdoglogger.h
#ifndef FDOGLOGGER_H
#define FDOGLOGGER_H
#include<iostream>
#include<fstream>
#include<map>
#include<mutex>
#ifndef linux
#include<unistd.h>
#include<sys/syscall.h>
#include<sys/stat.h>
#include<sys/types.h>
#include <pwd.h>
#endif
#ifndef WIN32
//TODO
#endif
using namespace std;

namespace fdog {

#define RED   "\e[1;31m"
#define BLUE  "\e[1;34m"
#define GREEN "\e[1;32m"
#define WHITE "\e[1;37m"
#define DEFA  "\e[0m"

enum class coutType: int {Error, Warn, Info, Debug, Trace};
enum class fileType: int {Error, Warn, Info, Debug, Trace};
enum class terminalType: int {Error, Warn, Info, Debug, Trace};

struct Logger {
    string logSwitch;           //日志开关
    string logFileSwitch;       //是否写入文件
    string logTerminalSwitch;   //是否打印到终端
    string logName;             //日志文件名字
    string logFilePath;         //日志文件保存路径
    string logMixSize;          //日志文件最大大小
    string logBehavior;         //日志文件达到最大大小行为
    string logOverlay;          //日志文件覆盖时间
    string logOutputLevelFile;  //日志输出等级(file)
    string logOutputLevelTerminal;//日志输出等级
};

class FdogLogger {
public:
    void initLogConfig();

    void releaseConfig();

    static FdogLogger* getInstance();

    string getCoutType(coutType coutType);

    bool getFileType(fileType fileCoutBool);

    bool getTerminalType(terminalType terminalCoutTyle);

    string getLogCoutTime();

    string getLogNameTime();

    string getFilePash();

    string getLogCoutProcessId();

    string getLogCoutThreadId();

    string getLogCoutUserName();

    bool createFile(string filePash);

    bool logFileWrite(string messages);

    bool bindFileCoutMap(string value1, fileType value2);

    bool bindTerminalCoutMap(string value1, terminalType value2);

private:
    char szbuf[128];
    Logger logger;
    static FdogLogger * singleObject;
    static mutex * mutex_new;
    map<coutType, string> coutTypeMap;
    map<fileType, bool> fileCoutMap;
    map<terminalType, bool> terminalCoutMap;

private:
    FdogLogger();
    ~FdogLogger();
};

#define Error1 __FDOGNAME__(Error)
#define Warn1 __FDOGNAME__(Warn)
#define Info1 __FDOGNAME__(Info)
#define Debug1 __FDOGNAME__(Debug)
#define Trace1 __FDOGNAME__(Trace)


#define SQUARE_BRACKETS_LEFT " ["
#define SQUARE_BRACKETS_RIGHT "] "
#define SPACE " "
#define LINE_FEED "\n"
#define COLON ":"
#define SLASH "/"

#define __FDOGTIME__  FdogLogger::getInstance()->getLogCoutTime()          //时间宏
#define __FDOGPID__   FdogLogger::getInstance()->getLogCoutProcessId()     //进程宏
#define __FDOGTID__   FdogLogger::getInstance()->getLogCoutThreadId()      //线程宏
#define __FDOGFILE__  __FILE__        //文件名宏
#define __FDOGPASH__  FdogLogger::getInstance()->getFilePash() + __FDOGFILE__ //文件路径
#define __FDOGFUNC__   __func__        //函数名宏
#define __FDOGLINE__  __LINE__        //行数宏
#define __USERNAME__  FdogLogger::getInstance()->getLogCoutUserName()     //获取调用用户名字
#define __FDOGNAME__(name) #name        //名字宏


#define COMBINATION_INFO_FILE(coutTypeInfo, message) \
    do{\
        string messagesAll = __FDOGTIME__ + coutTypeInfo + __USERNAME__ + __FDOGTID__ + SQUARE_BRACKETS_LEFT + \
        __FDOGPASH__  + SPACE +__FDOGFUNC__ + COLON + to_string(__FDOGLINE__) + SQUARE_BRACKETS_RIGHT + message + LINE_FEED;\
        FdogLogger::getInstance()->logFileWrite(messagesAll); \
    }while(0);

#define COMBINATION_INFO_TERMINAL(coutTypeInfo, message) \
    do{\
        string messagesAll = __FDOGTIME__ + WHITE + coutTypeInfo + DEFA + __USERNAME__ + __FDOGTID__ + SQUARE_BRACKETS_LEFT + \
        __FDOGPASH__  + SPACE +__FDOGFUNC__ + COLON + to_string(__FDOGLINE__) + SQUARE_BRACKETS_RIGHT + message + LINE_FEED;\
        cout << messagesAll;\
    }while(0);

#define LoggerCout(coutTyle, coutTypeInfo, fileCoutBool, terminalCoutBool, message) \
    do {\
        string coutType = FdogLogger::getInstance()->getCoutType(coutTyle);\
        if (FdogLogger::getInstance()->getFileType(fileCoutBool)) {\
            COMBINATION_INFO_FILE(coutTypeInfo, message)\
        }\
        if (FdogLogger::getInstance()->getTerminalType(terminalCoutBool)) {\
            COMBINATION_INFO_TERMINAL(coutTypeInfo, message)\
        }\
    }while(0);

#define FdogError(message) \
    do{\
        LoggerCout(fdog::coutType::Error, Error1, fdog::fileType::Error, fdog::terminalType::Error, message)\
    }while(0);

#define FdogWarn(message)  \
    do{\
        LoggerCout(fdog::coutType::Warn, Warn1, fdog::fileType::Warn, fdog::terminalType::Warn, message)\
    }while(0);

#define FdogInfo(message)  \
    do{\
        LoggerCout(fdog::coutType::Info, Info1, fdog::fileType::Info, fdog::terminalType::Info, message)\
    }while(0);

#define FdogDebug(message) \
    do{\
        LoggerCout(fdog::coutType::Debug, Debug1, fdog::fileType::Debug, fdog::terminalType::Debug, message)\
    }while(0);

#define FdogTrace(message) \
    do{\
        LoggerCout(fdog::coutType::Trace, Trace1, fdog::fileType::Trace, fdog::terminalType::Trace, message)\
    }while(0);

}

#endif
2. fdoglogger.cpp
#include"fdoglogger.h"

using namespace fdog;


FdogLogger * FdogLogger::singleObject = nullptr;
mutex * FdogLogger::mutex_new = new(mutex);

FdogLogger::FdogLogger(){
    initLogConfig();
}
FdogLogger::~FdogLogger(){

}

FdogLogger* FdogLogger::getInstance(){
    mutex_new->lock();
    if (singleObject == nullptr) {
        singleObject = new FdogLogger();
    }
    mutex_new->unlock();
    return singleObject;
}

void FdogLogger::initLogConfig(){

    map<string, string *> flogConfInfo;
    flogConfInfo["logSwitch"] = &this->logger.logSwitch;
    flogConfInfo["logFileSwitch"] = &this->logger.logFileSwitch;
    flogConfInfo["logTerminalSwitch"] = &this->logger.logTerminalSwitch;
    flogConfInfo["logName"] = &this->logger.logName;
    flogConfInfo["logFilePath"] = &this->logger.logFilePath;
    flogConfInfo["logMixSize"] = &this->logger.logMixSize;
    flogConfInfo["logBehavior"] = &this->logger.logBehavior;
    flogConfInfo["logOverlay"] = &this->logger.logOverlay;
    flogConfInfo["logOutputLevelFile"] = &this->logger.logOutputLevelFile;
    flogConfInfo["logOutputLevelTerminal"] = &this->logger.logOutputLevelTerminal;

    string str;
    ifstream file;
    char str_c[100]={0};
    file.open("fdoglogconf.conf");
    if(!file.is_open()){
        cout<<"文件打开失败\n";
    }
    while(getline(file, str)){
        if(!str.length()) {
            continue;
        }
        string str_copy = str;
        //cout<<"获取数据："<<str_copy<<endl;
        int j = 0;
        for(int i = 0; i < str.length(); i++){
            if(str[i]==' ')continue;
            str_copy[j] = str[i];
            j++;
        }
        str_copy.erase(j);
        if(str_copy[0]!='#'){
            sscanf(str_copy.data(),"%[^=]",str_c);
            auto iter = flogConfInfo.find(str_c);
            if(iter!=flogConfInfo.end()){
                sscanf(str_copy.data(),"%*[^=]=%s",str_c);
                *iter->second = str_c;
            } else {
            }
        }
    }
    logger.logName = logger.logName + getLogNameTime() + ".log";

    bindFileCoutMap("5", fileType::Error);
    bindFileCoutMap("4", fileType::Warn);
    bindFileCoutMap("3", fileType::Info);
    bindFileCoutMap("2", fileType::Debug);
    bindFileCoutMap("1", fileType::Trace);

    bindTerminalCoutMap("5", terminalType::Error);
    bindTerminalCoutMap("4", terminalType::Warn);
    bindTerminalCoutMap("3", terminalType::Info);
    bindTerminalCoutMap("2", terminalType::Debug);
    bindTerminalCoutMap("1", terminalType::Trace);

    if(logger.logFileSwitch == "on"){
        if(!createFile(logger.logFilePath)){
            std::cout<<"Log work path creation failed\n";
        }
    }

    cout << "|========FdogLogger v2.0==========================|" <<endl << endl;
    cout << "  日志开关：" << logger.logSwitch << endl;
    cout << "  文件输出：" << logger.logFileSwitch << endl;
    cout << "  终端输出：" << logger.logTerminalSwitch << endl;
    cout << "  日志输出等级(文件)：" << logger.logOutputLevelFile << endl;    
    cout << "  日志输出等级(终端)：" << logger.logOutputLevelTerminal << endl;
    cout << "  日志文件名：" << logger.logName << endl;
    cout << "  日志保存路径：" << logger.logFilePath << endl;
    cout << "  单文件最大大小："<< logger.logMixSize << "M" << endl;
    cout << "  日志保存时间 ：" << logger.logOverlay << "天" << endl << endl;
    cout << "|=================================================|" <<endl;
    
    return;
}

string FdogLogger::getCoutType(coutType coutType){
    return singleObject->coutTypeMap[coutType];
}

bool FdogLogger::getFileType(fileType fileCoutBool){
    return singleObject->fileCoutMap[fileCoutBool];
}

bool FdogLogger::getTerminalType(terminalType terminalCoutTyle){
    return singleObject->terminalCoutMap[terminalCoutTyle];
}

string FdogLogger::getLogCoutTime(){
    time_t timep;
    time (&timep);
    char tmp[64];
    strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S",localtime(&timep));
    string tmp_str = tmp;

    return SQUARE_BRACKETS_LEFT + tmp_str + SQUARE_BRACKETS_RIGHT;
}

string FdogLogger::getLogNameTime(){
    time_t timep;
    time (&timep);
    char tmp[64];
    strftime(tmp, sizeof(tmp), "%Y-%m-%d-%H:%M:%S",localtime(&timep));
    return tmp;
}

string FdogLogger::getFilePash(){
    getcwd(szbuf, sizeof(szbuf)-1);
    string szbuf_str = szbuf;
    return szbuf_str + SLASH;
}

string FdogLogger::getLogCoutProcessId(){
#ifndef linux
    return to_string(getpid());
#endif
#ifndef WIN32
//  unsigned long GetPid(){
//     return GetCurrentProcessId();
// }
#endif
}

string FdogLogger::getLogCoutThreadId(){
#ifndef linux
    return to_string(syscall(__NR_gettid));
#endif
#ifndef WIN32
//  unsigned long GetTid(){
//     return GetCurrentThreadId();
// }
#endif
}

string FdogLogger::getLogCoutUserName(){
    struct passwd *my_info;
    my_info = getpwuid(getuid());
    string name = my_info->pw_name;
    return SPACE + name + SPACE;
}

bool FdogLogger::createFile(string filePash){
    int len = filePash.length();
    if(!len){
        filePash = "log";
        if (0 != access(filePash.c_str(), 0)){
            if(-1 == mkdir(filePash.c_str(),0)){
                std::cout<<"没路径";
                return 0;
            }
        }
    }
    std::string filePash_cy(len,'\0');
    for(int i =0;i<len;i++){
        filePash_cy[i]=filePash[i];
        if(filePash_cy[i]=='/' || filePash_cy[i]=='\\'){
            if (-1 == access(filePash_cy.c_str(), 0)){
                if(0!=mkdir(filePash_cy.c_str(),0)){
                    std::cout<<"有路径";
                    return 0;
                }
            }
        }
    }
    return 1;
}

bool FdogLogger::logFileWrite(string messages){
    ofstream file;
    file.open(logger.logFilePath + logger.logName, ::ios::app | ios::out);
    if(!file){
        cout<<"写失败"<<endl;
        return 0;
    }
    file << messages;
    file.close();
    return 1;
}

bool FdogLogger::bindFileCoutMap(string value1, fileType value2){
    if(logger.logOutputLevelFile.find(value1)!=std::string::npos) {
        fileCoutMap[value2] = true;
    } else {
        fileCoutMap[value2] = false;
    }
}

bool FdogLogger::bindTerminalCoutMap(string value1, terminalType value2){
    if(logger.logOutputLevelTerminal.find(value1)!=std::string::npos) {
        terminalCoutMap[value2] = true;
    } else {
        terminalCoutMap[value2] = false;
    }
}

四. 测试用例

在这里插入图片描述

1. fdoglogger_test.cpp
#include<iostream>
#include"fdoglogger.h"  //添加日志库头文件

using namespace fdog;   //日志库的命名空间

int main(){
    FdogError("错误");
    FdogWarn("警告");
    FdogInfo("信息");
    FdogDebug("调试");
    FdogTrace("追踪");
    return 0;
}

在这里插入图片描述

在这里插入图片描述

暂时考虑到的就是这些，如有缺陷，欢迎评论区补充。(比如文件写入打开就关闭，很浪费资源，如何优化，下篇见)。

源码已上传github，还原star！ FdogLog，一个轻量级C++日志库，用于日志服务。

文章标签：
日志服务
C++
测试技术
监控
安全
关键词：
C++学习
C++库
日志服务学习
c++日志服务
C++日志
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
1808604787721125
目录
相关文章
蓝易云
|
19天前
|
C++ 开发者
C++学习之继承
通过继承，C++可以实现代码重用、扩展类的功能并支持多态性。理解继承的类型、重写与重载、多重继承及其相关问题，对于掌握C++面向对象编程至关重要。希望本文能为您的C++学习和开发提供实用的指导。
蓝易云
49 16
是乙太呀
|
1月前
|
算法 网络安全 区块链
2023/11/10学习记录-C/C++对称分组加密DES
本文介绍了对称分组加密的常见算法（如DES、3DES、AES和国密SM4）及其应用场景，包括文件和视频加密、比特币私钥加密、消息和配置项加密及SSL通信加密。文章还详细展示了如何使用异或实现一个简易的对称加密算法，并通过示例代码演示了DES算法在ECB和CBC模式下的加密和解密过程，以及如何封装DES实现CBC和ECB的PKCS7Padding分块填充。
是乙太呀
59 4
2023/11/10学习记录-C/C++对称分组加密DES
土木林森
|
5月前
|
算法 C语言 C++
C++语言学习指南：从新手到高手，一文带你领略系统编程的巅峰技艺！
【8月更文挑战第22天】C++由Bjarne Stroustrup于1985年创立，凭借卓越性能与灵活性，在系统编程、游戏开发等领域占据重要地位。它继承了C语言的高效性，并引入面向对象编程，使代码更模块化易管理。C++支持基本语法如变量声明与控制结构；通过`iostream`库实现输入输出；利用类与对象实现面向对象编程；提供模板增强代码复用性；具备异常处理机制确保程序健壮性；C++11引入现代化特性简化编程；标准模板库(STL)支持高效编程；多线程支持利用多核优势。虽然学习曲线陡峭，但掌握后可开启高性能编程大门。随着新标准如C++20的发展，C++持续演进，提供更多开发可能性。
土木林森
99 0
梦笔生花伟
|
3月前
|
编译器 C语言 C++
配置C++的学习环境
【10月更文挑战第18天】如果想要学习C++语言，那就需要配置必要的环境和相关的软件，才可以帮助自己更好的掌握语法知识。 一、本地环境设置 如果您想要设置 C++ 语言环境，您需要确保电脑上有以下两款可用的软件，文本编辑器和 C++ 编译器。 二、文本编辑器 通过编辑器创建的文件通常称为源文件，源文件包含程序源代码。 C++ 程序的源文件通常使用扩展名 .cpp、.cp 或 .c。 在开始编程之前，请确保您有一个文本编辑器，且有足够的经验来编写一个计算机程序，然后把它保存在一个文件中，编译并执行它。 Visual Studio Code：虽然它是一个通用的文本编辑器，但它有很多插
梦笔生花伟
80 6
nanshaws
|
3月前
|
Java 编译器 C++
c++学习，和友元函数
本文讨论了C++中的友元函数、继承规则、运算符重载以及内存管理的重要性，并提到了指针在C++中的强大功能和使用时需要注意的问题。
nanshaws
36 1
石小石Orz
|
5月前
|
前端开发 C语言 开发者
领导被我的花式console.log吸引了！直接写入公司公共库！
【8月更文挑战第23天】领导被我的花式console.log吸引了！直接写入公司公共库！
石小石Orz
57 2
领导被我的花式console.log吸引了！直接写入公司公共库！
蓝易云
|
3月前
|
缓存 Linux 编译器
【C++】CentOS环境搭建-安装log4cplus日志组件包及报错解决方案
通过上述步骤，您应该能够在CentOS环境中成功安装并使用log4cplus日志组件。面对任何安装或使用过程中出现的问题，仔细检查错误信息，对照提供的解决方案进行调整，通常都能找到合适的解决之道。log4cplus的强大功能将为您的项目提供灵活、高效的日志管理方案，助力软件开发与维护。
蓝易云
111 0
希望_睿智
|
4月前
|
存储 运维 监控
超级好用的C++实用库之日志类
超级好用的C++实用库之日志类
希望_睿智
64 0
路边两盏灯
|
5月前
|
Java C++
【Azure Function】开启Azure Function输出详细Debug日志 ( --verbose)
【Azure Function】开启Azure Function输出详细Debug日志 ( --verbose)
路边两盏灯
49 0
RossyYan
|
16天前
|
C++ 芯片
【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
声明一个简单的Computer类，含有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制，用于保护类的数据不被外部随意修改。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。成员可以在派生类（继承该类的子类）中访问。成员，在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务，你需要掌握。
RossyYan
58 19

热门文章

最新文章

  • 1
    【C++数据结构——栈与队列】顺序栈的基本运算（头歌实践教学平台习题）【合集】
  • 2
    【C++数据结构——查找】二分查找（头歌实践教学平台习题）【合集】
  • 3
    C++ 简介
  • 4
    【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
  • 5
    【硬核】C++11并发：内存模型和原子类型
  • 6
    【C++数据结构——树】哈夫曼树（头歌实践教学平台习题） 【合集】
  • 7
    用 C++ 算法控制员工上网的软件，关键逻辑是啥？来深度解读下
  • 8
    C++学习之继承
  • 9
    探秘：基于 C++ 的局域网电脑控制软件自适应指令分发算法
  • 10
    【C++数据结构——图】最短路径（头歌教学实验平台习题） 【合集】
  • 1
    DataWorks产品使用合集之如何查看数据服务API发布后的服务端日志
    93
  • 2
    systemd-cat：Linux 系统日志的管道
    117
  • 3
    seata2.0服务器日志位置修改
    209
  • 4
    实时计算 Flink版操作报错合集之在写入SLS（Serverless Log Service）时出现报错，该如何排查
    97
  • 5
    实时计算 Flink版产品使用问题之如何解决Flink集群在nativeKubernetes部署方式下日志无法映射到宿主机并容易丢失的问题
    94
  • 6
    实时计算 Flink版产品使用问题之在online模式下增量抓取Oracle数据时，在archive_log切换时，出现数据丢失的情况，是什么原因
    64
  • 7
    《手把手教你》系列基础篇（九十五）-java+ selenium自动化测试-框架之设计篇-java实现自定义日志输出（详解教程）
    319
  • 8
    Python代码示例：使用`syslog`模块进行日志记录
    188
  • 9
    查看服务器/IIS日志、log、访问信息基本方法
    783
  • 10
    【vue】 将Vue2中的console.log()调试信息移除
    251

    • 相关课程

    更多
  • 基于MongoDB构建实时日志分析平台
  • 日志服务SLS实现云产品可观测
  • 日志服务 SLS 可观测数据分析平台介绍
  • 大数据知识图谱系列—基于ELK+Flink日志全观测最佳实践
  • 场景实践-基于阿里云Quick BI 对MOOC网站日志分析
  • C++ 入门教程开发文档

    • 相关电子书

    更多
  • PostgresChina2018_赖思超_PostgreSQL10_hash索引的WAL日志修改版final
  • Kubernetes下日志实时采集、存储与计算实践
  • 日志数据采集与分析对接

    • 相关实验场景

    更多
  • 使用CloudLens管理SLS日志采集
  • 使用CloudLens采集PolarDB日志并进行审计分析
  • 使用CloudLens采集RDS日志并进行审计分析
  • 使用日志服务SLS进行OSS可观测分析
  • 多账号体系下使用日志服务中心化的管理日志
  • 日志服务之告警接入与管理
    • 下一篇
    阿里云oss简介和如何对接使用