初始化列表的方式来初始化字段 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 <iostream>
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 ;
}