C++如何使用初始化列表的方式来初始化字段-创新互联
小编给大家分享一下C++如何使用初始化列表的方式来初始化字段，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！
几个月之前，接触Android recovery源代码的时候，看ScreenRecoveryUI类的时候，那时候C++基础还不是特别好，一直不明白以下的初始化方式：
下面这个是Recovery的一个构造函数，代码位于：screen_ui.cpp，它的类的实现在screen_ui.h。
如下这个ScreenRecoveryUI类，这个类是继承于RecoveryUI类的：
这个文件在screen_ui.h
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);
};下面是这个类的构造函数的实现，其中构造函数就采用了初始化列表的方式来初始化字段，以下构造函数的实现在screen_ui.cpp文件中可以找到。
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);
}可以来看看RecoveryUI类:
在ui.h中：
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));
}现在看明白了。
写一个测试案例看看就懂了，果然一例解千愁啊！
#includeusing 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 ; }
运行结果：
r:255
g:255
b:0
以上是“C++如何使用初始化列表的方式来初始化字段”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注创新互联网站建设公司行业资讯频道！
另外有需要云服务器可以了解下创新互联建站www.cdcxhl.com，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。
文章名称：C++如何使用初始化列表的方式来初始化字段-创新互联
标题URL：http://shouzuofang.com/article/csioee.html