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,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,

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,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 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++使用初始化列表的方式来初始化字段的方法全部内容，希望文章能够帮你解决C++使用初始化列表的方式来初始化字段的方法所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。