C++使用初始化列表的方式来初始化字段的方法

 class ScreenRecoveryUI : public RecoveryUI { public: ScreenRecoveryUI(); void Init(); void SetLocale(const char* locale); // overall recovery state ("background image") void SetBackground(Icon icon); // progress indicator void SetProgressType(ProgressType type); void ShowProgress(float portion, float seconds); void SetProgress(float fraction); void SetStage(int current, int max); // text log void ShowText(bool visible); bool IsTextVisible(); bool WasTextEverVisible(); // printing messages void Print(const char* fmt, ...) __printflike(2, 3); void ShowFile(const char* filename); // menu display void StartMenu(const char* const * headers, const char* const * items, int initial_selection); int SelectMenu(int sel); void EndMenu(); void KeyLongPress(int); void Redraw(); enum UIElement { HEADER, MENU, MENU_SEL_BG, MENU_SEL_BG_ACTIVE, MENU_SEL_FG, LOG, TEXT_FILL, INFO }; void SetColor(UIElement e); private: Icon currentIcon; int installingFrame; const char* locale; bool rtl_locale; pthread_mutex_t updateMutex; GRSurface* backgroundIcon[5]; GRSurface* backgroundText[5]; GRSurface** installation; GRSurface* progressBarEmpty; GRSurface* progressBarFill; GRSurface* stageMarkerEmpty; GRSurface* stageMarkerFill; ProgressType progressBarType; float progressScopeStart, progressScopeSize, progress; double progressScopeTime, progressScopeDuration; // true when both graphics pages are the same (except for the progress bar). bool pagesIdentical; size_t text_cols_, text_rows_; // Log text overlay, displayed when a magic key is pressed. char** text_; size_t text_col_, text_row_, text_top_; bool show_text; bool show_text_ever;  // has show_text ever been true? char** menu_; const char* const* menu_headers_; bool show_menu; int menu_items, menu_sel; // An alternate text screen, swapped with 'text_' when we're viewing a log file. char** file_viewer_text_; pthread_t progress_thread_; int animation_fps; int installing_frames; int iconX, iconY; int stage, max_stage; void draw_background_locked(Icon icon); void draw_progress_locked(); void draw_screen_locked(); void update_screen_locked(); void update_progress_locked(); static void* ProgressThreadStartRoutine(void* data); void ProgressThreadLoop(); void ShowFile(FILE*); void PutChar(char); void ClearText(); void DrawHorizontalRule(int* y); void DrawTextLine(int* y, const char* line, bool bold); void DrawTextLines(int* y, const char* const* lines); void LoadBitmap(const char* filename, GRSurface** surface); void LoadBitmapArray(const char* filename, int* frames, GRSurface*** surface); void LoadLocalizedBitmap(const char* filename, GRSurface** surface); };

 ScreenRecoveryUI::ScreenRecoveryUI() : currentIcon(NONE), installingFrame(0), locale(nullptr), rtl_locale(false), progressBarType(EMPTY), progressScopeStart(0), progressScopeSize(0), progress(0), pagesIdentical(false), text_cols_(0), text_rows_(0), text_(nullptr), text_col_(0), text_row_(0), text_top_(0), show_text(false), show_text_ever(false), menu_(nullptr), show_menu(false), menu_items(0), menu_sel(0), file_viewer_text_(nullptr), animation_fps(20), installing_frames(-1), stage(-1), max_stage(-1) { for (int i = 0; i <5; i++) { backgroundIcon[i] = nullptr; } pthread_mutex_init(&updateMutex, nullptr); }

 class RecoveryUI { public: RecoveryUI(); virtual ~RecoveryUI() { } // Initialize the object; called before anything else. virtual void Init(); // Show a stage indicator. Call immediately after Init(). virtual void SetStage(int current, int max) = 0; // After calling Init(), you can tell the UI what locale it is operating in. virtual void SetLocale(const char* locale) = 0; // Set the overall recovery state ("background image"). enum Icon { NONE, INSTALLING_UPDATE, ERASING, NO_COMMAND, ERROR }; virtual void SetBackground(Icon icon) = 0; // --- progress indicator --- enum ProgressType { EMPTY, INDETERMINATE, DETERMINATE }; virtual void SetProgressType(ProgressType determinate) = 0; // Show a progress bar and define the scope of the next operation: //  portion - fraction of the progress bar the next operation will use //  seconds - expected time interval (progress bar moves at this minimum rate) virtual void ShowProgress(float portion, float seconds) = 0; // Set progress bar position (0.0 - 1.0 within the scope defined // by the last call to ShowProgress). virtual void SetProgress(float fraction) = 0; // --- text log --- virtual void ShowText(bool visible) = 0; virtual bool IsTextVisible() = 0; virtual bool WasTextEverVisible() = 0; // Write a message to the on-screen log (shown if the user has // toggled on the text display). virtual void Print(const char* fmt, ...) __printflike(2, 3) = 0; virtual void ShowFile(const char* filename) = 0; // --- key handling --- // Wait for a key and return it. May return -1 after timeout. virtual int WaitKey(); virtual bool IsKeyPressed(int key); virtual bool IsLongPress(); // Returns true if you have the volume up/down and power trio typical // of phones and tablets, false otherwise. virtual bool HasThreeButtons(); // Erase any queued-up keys. virtual void FlushKeys(); // Called on each key press, even while operations are in progress. // Return value indicates whether an immediate operation should be // triggered (toggling the display, rebooting the device), or if // the key should be enqueued for use by the main thread. enum KeyAction { ENQUEUE, TOGGLE, REBOOT, IGNORE }; virtual KeyAction CheckKey(int key, bool is_long_press); // Called when a key is held down long enough to have been a // long-press (but before the key is released). This means that // if the key is eventually registered (released without any other // keys being pressed in the meantime), CheckKey will be called with // 'is_long_press' true. virtual void KeyLongPress(int key); // Normally in recovery there's a key sequence that triggers // immediate reboot of the device, regardless of what recovery is // doing (with the default CheckKey implementation, it's pressing // the power button 7 times in row). Call this to enable or // disable that feature. It is enabled by default. virtual void SetEnableReboot(bool enabled); // --- menu display --- // Display some header text followed by a menu of items, which appears // at the top of the screen (in place of any scrolling ui_print() // output, if necessary). virtual void StartMenu(const char* const * headers, const char* const * items, int initial_selection) = 0; // Set the menu highlight to the given index, wrapping if necessary. // Returns the actual item selected. virtual int SelectMenu(int sel) = 0; // End menu mode, resetting the text overlay so that ui_print() // statements will be displayed. virtual void EndMenu() = 0; protected: void EnqueueKey(int key_code); private: // Key event input queue pthread_mutex_t key_queue_mutex; pthread_cond_t key_queue_cond; int key_queue[256], key_queue_len; char key_pressed[KEY_MAX + 1];   // under key_queue_mutex int key_last_down;         // under key_queue_mutex bool key_long_press;        // under key_queue_mutex int key_down_count;        // under key_queue_mutex bool enable_reboot;        // under key_queue_mutex int rel_sum; int consecutive_power_keys; int last_key; bool has_power_key; bool has_up_key; bool has_down_key; struct key_timer_t { RecoveryUI* ui; int key_code; int count; }; pthread_t input_thread_; void OnKeyDetected(int key_code); static int InputCallback(int fd, uint32_t epevents, void* data); int OnInputEvent(int fd, uint32_t epevents); void ProcessKey(int key_code, int updown); bool IsUsbConnected(); static void* time_key_helper(void* cookie); void time_key(int key_code, int count); }; ui.cpp中，也是采用字段初始化的方式来实现构造函数： RecoveryUI::RecoveryUI() : key_queue_len(0), key_last_down(-1), key_long_press(false), key_down_count(0), enable_reboot(true), consecutive_power_keys(0), last_key(-1), has_power_key(false), has_up_key(false), has_down_key(false) { pthread_mutex_init(&key_queue_mutex, nullptr); pthread_cond_init(&key_queue_cond, nullptr); memset(key_pressed, 0, sizeof(key_pressed)); }

 #include  using namespace std ; class ScreenRecoveryUI { private : int r , g , b ; char buffer[10] ; char *p ; public : ScreenRecoveryUI(); void setvalue(int a , int b , int c); void print(); }; //使用初始化列表的方式初始化构造函数里的私有环境变量 ScreenRecoveryUI::ScreenRecoveryUI(): r(0), g(0), b(0), p(nullptr){ for(int i = 0 ; i <10 ; i++){ buffer[i]=0 } void screenrecoveryui::setvalue(int a ,int b , int c) { this->r = a ; this->g = b ; this->b = c ; } void ScreenRecoveryUI::print() { cout << "r:" << this->r << endl << "g:" << this->g << endl << "b:" << b << endl ; } int main(void) { ScreenRecoveryUI screen ; screen.setvalue(255,255,0); screen.print(); return 0 ; }