自学教程：C++ string_to_int函数代码示例

int main() {	printf("%d/n", string_to_int("123"));	printf("%d/n", string_to_int("-123"));	return 0;}

static int assemble_constant(assembly_state_t *state,                        instruction_t *instr, uint32_t addr, uint32_t *offset){    /* PRE:  Given state is initialised. Instruction is valid SDTR instruction.              offset points to sufficient space to store uint32_t. */    /* POST: Loads the assembled constant into relevant bits in number pointed              to by offset. Returns 0 if successful, 1 otherwise. */    assert (state != NULL && instr != NULL && offset != NULL);    uint32_t expression = string_to_int(instr->ops[1]);     /* If the expression is <= 0xff we use a mov function instead: */    if (expression <= 0xff) {        /* Change the format of the operand from =0x... to #...            Will now be in decimal. */        sprintf(instr->ops[1], "#%d", string_to_int(instr->ops[1]));        strcpy(instr->mnemonic, "mov");        instr->no_of_ops = 2;        return EXIT_FAILURE;    } else {        /* We allocate 4 bytes at end of program for the expression: */        add_to_data_aloc_table(state->data_aloc_table, addr, expression);        *offset |= 0x000f0000;    }     return EXIT_SUCCESS;}

static void finish_recovery_recv_file_name(struct aeEventLoop *eventLoop, int sockfd, void *clientData, int mask){	storage_client_t *pClient;	pClient = clientData;		pClient->file.proc = finish_recv_recovery_file;	pClient->file.start_offlen = string_to_int(pClient->file.file_name + 15,4);	pClient->file.file_size = string_to_int(pClient->file.file_name + 19,4);	memcpy(pClient->file.real_file_name,pClient->file.file_name,24);	logDebug("finish_recovery_recv_file_name %s",pClient->file.file_name);	/*get all_trunk_name*/		memcpy(pClient->file.file_name,pClient->file.file_name+8,5);	pClient->file.file_name[5] = '/0';	logDebug("finish_recovery_recv_trunk_name %d,%d,%s",pClient->file.file_size,pClient->file.start_offlen,pClient->file.file_name);	if((pClient->file.fd = open(pClient->file.file_name,O_WRONLY|O_CREAT,0664)) == -1)	{		logError(	"file: "__FILE__",line :%d, "/			"finish_recovery_recv_file_name open file failed,"/			"errno: %d,error info: %s",/			__LINE__,errno,strerror(errno));		*(char *)NULL = 0;	//	exit(1);	}	lseek(pClient->file.fd,pClient->file.start_offlen,SEEK_SET);	nb_sock_recv_file(eventLoop,sockfd,pClient,AE_READABLE);		return ;}

void cBonusBox::Load_From_XML(XmlAttributes& attributes){    cBaseBox::Load_From_XML(attributes);    // item    Set_Bonus_Type(static_cast<SpriteType>(string_to_int(attributes["item"])));    // force best possible item    Set_Force_Best_Item(string_to_int(attributes["force_best_item"]));    // gold color    if (box_type == TYPE_GOLDPIECE)        Set_Goldcolor(Get_Color_Id(attributes.fetch("gold_color", Get_Color_Name(m_gold_color))));}

int main(int argc, char *argv[]) {		char number_array[MAX_LENGTH_ARRAY]; 									// Array che verrà passato alla funzione int_to_string	unsigned int result;													// Il risultato è dove verrà salvato il risultato di string_to_int	if (argc == 2) {														// Se gli argomenti passati sono due 		if (( strcmp(argv[1], "-unit") == 0)) {								// ed il secondo è '-unit'			debug = 1;			unit_test() == 0 ? printf("[+] Unit test Riuscito/n") : printf("[!] Unit test Fallito/n");  // Avvia gli unit test				} else {			printf("[!] Argomento sconosciuto/n");							// se il secondo argomento non è '-unit'			usage();														// richiama la funzione 'usage'			return 1;		}														} else if ( argc != 4) {												// se gli argomenti passati non sono due e non sono neanche 4		usage();															// richiama la funzione 'usage'	} else {		char* numero_da_convertire = argv[1];		char* base_di_partenza = argv[2];		char* base_di_arrivo = argv[3];		int partenza = string_to_int(base_di_partenza, 10);						// Base di partenza convertita in int per passarla alle funzioni		int arrivo = string_to_int(base_di_arrivo, 10);							// Base di arrivo convertita in int per passarla alle funzioni		if (controllo_numero_base(numero_da_convertire, partenza, arrivo) == 1) {			if(controllo_input(numero_da_convertire) == 1) {				if (arrivo == 10) {												// Se la base di arrivo è 10 usiamo string_to_int					result = string_to_int(numero_da_convertire, partenza);					printf("%i/n", result);										// Stampiamo a schermo il risultato				}				else {															// Se abbiamo un numero in base 10 da convertire a un'altra base usiamo int_to_string					int convertire = string_to_int(numero_da_convertire, partenza); // Il numero da convertire deve essere un int per into_to_string					int_to_string(convertire, number_array, arrivo);			// Non stampiamo il risultato perché viene stampato dalla funzione stessa				}			} else {				printf("La stringa inserita contiene dei caratteri non ammessi/n/n");				return 1;			}		} else if (controllo_numero_base(numero_da_convertire, partenza, arrivo) == -1)  {			printf("Il numero inserito non può far parte della base %d/n/n", partenza);			return 1;		} else {			printf("Il numero inserito non può essere convertito nella base %d/n", arrivo);		}	}		return 0;														// Terminiamo il programma} 

//executa alguns comandos como cd e pwd...int execute_int_commands(StringList arguments){    String command = get_string(arguments, 0);    if(equals(command, "cd")){        if(chdir(get_string(arguments, 1))){            printf("Error: no such directory/n");            return 0;        }    }else if(equals(command, "pwd")){        printf("%s/n", get_current_dir_name());    }else if(equals(command, "jobs")){        print_job_list(job_list);    }else if(equals(command,"fg")){        Job aux;         int pid = string_to_int(get_string(arguments, 1));         kill(pid, SIGCONT);        aux = get_by_pid(job_list, pid);         if (aux == NULL) {           //busca por jid            aux = get_by_jid(job_list, pid);            if (aux == NULL) {                printf("Error: job not found/n");                 return 0;            }        }        aux->status = RUNNING;         background = 0;        wait(NULL);     }else if(equals(command,"bg")){        Job aux;         int pid = string_to_int(get_string(arguments, 1));         kill(pid ,SIGCONT);        aux = get_by_pid(job_list, pid);         if (aux == NULL) {           //busca por jid            aux = get_by_jid(job_list, pid);            if (aux == NULL) {                printf("Error: job not found/n");                 return 0;            }        }        aux->status = RUNNING;        background = 1;     }else{        return 0;    }    return 1;}

bin2hex_input_t bin2hex_parse_command_line( char const* const* cmdline ){    bin2hex_input_t input = {0};    int arg, asize;    error_context_push( "parsing command line", "" );    for( arg = 1, asize = array_size( cmdline ); arg < asize; ++arg )    {        if( string_equal( cmdline[arg], "--columns" ) )        {            if( arg < ( asize - 1 ) )                input.columns = string_to_int( cmdline[++arg] );        }        else if( string_equal( cmdline[arg], "--" ) )            break; //Stop parsing cmdline options        else if( ( string_length( cmdline[arg] ) > 2 ) && string_equal_substr( cmdline[arg], "--", 2 ) )            continue; //Cmdline argument not parsed here        else        {            array_push( input.input_files, string_clone( cmdline[arg] ) );            array_push( input.output_files, string_format( "%s.hex", cmdline[arg] ) );        }    }    error_context_pop();    return input;}

void IterDialog::OnApply(wxCommandEvent& event){	// Redraw fractal.	text = textCtrl->GetValue();	number = string_to_int(text);	target->ChangeIterations(number);}

   int command_line_params::get_value_as_int(const wchar_t* pKey, uint index, int def, int l, int h, uint value_index) const   {      param_map_const_iterator it = get_param(pKey, index);      if ((it == end()) || (value_index >= it->second.m_values.size()))         return def;      int val;      const wchar_t* p = it->second.m_values[value_index].get_ptr();      if (!string_to_int(p, val))      {         crnlib::console::warning(L"Invalid value specified for parameter /"%s/", using default value of %i", pKey, def);         return def;      }      if (val < l)      {         crnlib::console::warning(L"Value %i for parameter /"%s/" is out of range, clamping to %i", val, pKey, l);         val = l;      }      else if (val > h)      {         crnlib::console::warning(L"Value %i for parameter /"%s/" is out of range, clamping to %i", val, pKey, h);         val = h;      }            return val;   }

int get_mp3_info (char *file_name, tihm_t *tihm) {  struct mp3_file mp3;  if (mp3_open (file_name, &mp3) < 0) {    mp3_close (&mp3); /* Make sure everything is cleaned up */    return -1;  }  if (mp3_scan (&mp3) < 0) {    mp3_close (&mp3);    return -1;  }  mp3_close (&mp3);  tihm->bitrate = mp3.bitrate;  tihm->vbr     = mp3.vbr;  tihm->samplerate = mp3.samplerate;  tihm->time       = mp3.duration;  tihm->size       = mp3.file_size;  tihm->mod_date   = mp3.mod_date;  tihm->creation_date = mp3.mod_date;  tihm->type      = string_to_int ("MP3 ");  tihm->is_video  = 0;  return 0;}

int main(){    int_to_string(-50, A);    printf("digit %d is string %s/n", -50, A);    printf("string 12345 is digit %d/n",string_to_int("-12345"));    return 0;}

void insertar_nodo(ListaNodo **ptrCabecera, ArbolNodo **ptrarbol, char **palabras, size_t largo_array, int contador){	int n_callback;	if(*ptrarbol==NULL){		ListaNodo *ptrAuxLista=NULL;		ArbolNodo *ptrAuxArbol=NULL;		ptrAuxArbol = malloc(sizeof(ArbolNodo));		ptrAuxLista = malloc(sizeof(ListaNodo));		ptrAuxArbol->children=NULL;		ptrAuxArbol->word="ROOT";		ptrAuxLista->data=ptrAuxArbol;		ptrAuxLista->siguiente=NULL;		*ptrarbol=ptrAuxArbol;		*ptrCabecera=ptrAuxLista;		}	else{		ArbolNodo *ptrAuxArbol=*ptrarbol;		ListaNodo *ptrAuxLista=*ptrCabecera;		if(ptrAuxArbol->children==NULL && contador<largo_array){			n_callback=string_to_int(palabras[0]);			//ListaNodo *ptrAuxLista=*ptrCabecera;			ptrAuxLista = malloc(sizeof(ListaNodo));			ptrAuxArbol = malloc(sizeof(ArbolNodo));			ptrAuxArbol->word=malloc(sizeof(char) * (strlen(palabras[contador]) + 1)); //completar con callbacks			strcpy(ptrAuxArbol->word,palabras[contador]);//revisar cuando llamamos recursivamente			ptrAuxArbol->children=NULL;			//*ptrArbol=ptrAuxArbol;			ptrAuxLista->data = ptrAuxArbol;			ptrAuxLista->siguiente = NULL;			(*ptrarbol)->children=ptrAuxLista;			//puts("ahora es cuando!");			insertar_nodo(&ptrAuxArbol->children, &ptrAuxLista->data,palabras,largo_array,contador+1);		}	}}

void Box::load_movies_seen(){	vector<Movie> Seen;	string s;	float c;	int t;	ifstream file;	file.open("info//Seen Movies.txt");	if (!file.fail())	{		while (!file.eof())		{			getline(file, s);			int i = 1;			string name, aux;			do			{				name.push_back(s.at(i));				i++;			} while (s.at(i) != '/"');			i+=2;			do			{				aux.push_back(s.at(i));				i++;			} while (s.at(i) != ' ');			c = string_to_float(aux);			t = string_to_int(s.substr(i + 1, s.length()));			Movie temp(name, c, t);			Seen.push_back(temp);		}		file.close();	}	seenMovies = Seen;}

static uint32_t assemble_expression(instruction_t *instr){    /* PRE:  Take a valid and legal pointer to an instruction. The address is              exactly [Rn, <#expression>] or "[Rn], <#expression>". */    /* POST: Returns the the value of the expression. */    assert (instr != NULL);     /* We will save the start and end of the string matched in match */    regmatch_t match[1];    regex_t regex;     /* We execute the regex on the instr->instr_str in order to know where the      * expression starts and finishes. The regex execution will save in match      * the index of start and end of the string matched. RE_HASH_EXP is a      * regex to check if a string contains an expression (i.e. #expression) */     check_and_compile_regex(&regex, RE_HASH_EXP, REG_EXTENDED);    regexec(&regex, instr->instr_str, 1, match, 0);       uint8_t start = (uint8_t) match->rm_so;    uint8_t end   = (uint8_t) match->rm_eo;     /* We cut the full_instruction keeping only the expression */    char *exp = cut_string(instr->instr_str, start, end);     regfree(&regex); /* We free the regex used */     return string_to_int(exp);}

void read_value (Logical newline, char *string, int *value, int lower_bound){   char response[MAXWORD];   Logical error;   Logical reading = TRUE;   int nmr_items;   while (reading) {      printf ("%s", string);      nmr_items = scanf ("%s", response);      verify_read (nmr_items, 1);      /* read past any comments */      while (response[0] == COMMENT) {	 read_line ();	 nmr_items = scanf ("%s", response);	 verify_read (nmr_items, 1);      }      if (!isatty (0)) printf ("%s ", response);      if (!isatty (0) && newline) printf ("/n");      *value = string_to_int (response, &error);      if (error) 	 printf ("Error in input -- must be integer only/n");      else if ((reading = (*value < lower_bound)))	 printf ("Error: supplied value must be at least %d/n", lower_bound);   }}

int get_int (const char * section, const char * name){    int value = 0;    char * string = get_string (section, name);    string_to_int (string, & value);    g_free (string);    return value;}

void cBackground::Load_From_Attributes(XmlAttributes& attributes){    Set_Type(static_cast<BackgroundType>(string_to_int(attributes["type"])));    if (m_type == BG_GR_HOR || m_type == BG_GR_VER) {        int r, g, b;        r = string_to_int(attributes["bg_color_1_red"]);        g = string_to_int(attributes["bg_color_1_green"]);        b = string_to_int(attributes["bg_color_1_blue"]);        Set_Color_1(Color(static_cast<Uint8>(r), static_cast<Uint8>(g), static_cast<Uint8>(b)));        r = string_to_int(attributes["bg_color_2_red"]);        g = string_to_int(attributes["bg_color_2_green"]);        b = string_to_int(attributes["bg_color_2_blue"]);        Set_Color_2(Color(static_cast<Uint8>(r), static_cast<Uint8>(g), static_cast<Uint8>(b)));    }    else if (m_type == BG_IMG_BOTTOM || m_type == BG_IMG_TOP || m_type == BG_IMG_ALL) {        Set_Start_Pos(string_to_float(attributes["posx"]), string_to_float(attributes["posy"]));        Set_Pos_Z(string_to_float(attributes["posz"]));        Set_Image(utf8_to_path(attributes["image"]));        Set_Scroll_Speed(string_to_float(attributes["speedx"]), string_to_float(attributes["speedy"]));        Set_Const_Velocity_X(string_to_float(attributes["const_velx"]));        Set_Const_Velocity_Y(string_to_float(attributes["const_vely"]));    }}

bool cFlyon::Editor_Max_Distance_Text_Changed(const CEGUI::EventArgs& event){    const CEGUI::WindowEventArgs& windowEventArgs = static_cast<const CEGUI::WindowEventArgs&>(event);    std::string str_text = static_cast<CEGUI::Editbox*>(windowEventArgs.window)->getText().c_str();    Set_Max_Distance(static_cast<float>(string_to_int(str_text)));    return 1;}

bool cLayer_Line_Point_Start :: Editor_Origin_Text_Changed( const CEGUI::EventArgs &event ){	const CEGUI::WindowEventArgs &windowEventArgs = static_cast<const CEGUI::WindowEventArgs&>( event );	std::string str_text = static_cast<CEGUI::Editbox *>( windowEventArgs.window )->getText().c_str();	m_origin = string_to_int( str_text );	return 1;}

int string_to_int_test(char *string, int base, int result) {	if (string_to_int(string, base) != result)						// se il test non da i risultati esatti	{		printf("Test fallito, %s in base %d dovrebbe diventare %d in base 10, invece risulta %d/n", string, base, result, string_to_int(string, base));		return -1;													// scrive un messaggio di errore ed esce dal ciclo	}	return 0;}

void cFlyon::Load_From_Savegame(cSave_Level_Object* save_object){    cEnemy::Load_From_Savegame(save_object);    // move_back    if (save_object->exists("move_back")) {        m_move_back = string_to_int(save_object->Get_Value("move_back")) > 0;    }}

bool is_RECORD_CORRECT (const vector<string>& SETrecord, const vector<vector<vector<string> > >& DEF, size_t j, size_t k) {	string actual_key = SETrecord.at(0);	string list_key = DEF.at(j).at(0).at(0);	if (actual_key != list_key) return false;	string actual_value = capslock (SETrecord.at(1));	string list_value = capslock (DEF.at(j).at(k).at(0));	if (actual_key == "LINEWIDTH:" || actual_key == "STRESSANGLE:" || actual_key == "WELLINTERVAL_LENGTH:") {		bool conv_has_failed = true;		double min_value = string_to_double (DEF.at(j).at(k).at(1), conv_has_failed);		double max_value = string_to_double (DEF.at(j).at(k).at(2), conv_has_failed);		string_to_int (actual_value, conv_has_failed);		if (actual_key == "LINEWIDTH:" && conv_has_failed) return false;		if (actual_key == "STRESSANGLE:" && conv_has_failed) return false;		if (actual_key == "WELLINTERVAL_LENGTH:" && conv_has_failed) return false;		double value = string_to_double (actual_value, conv_has_failed);		if (is_in_range(min_value, max_value, value) && !conv_has_failed) return true;		else return false;	}	else if (actual_key == "CLUSTERNUMBER:") {		if (actual_value == "A" || actual_value == "N") {			if (actual_value == list_value) return true;			else return false;		}		else {			bool conv_has_failed = true;			double min_value = string_to_double (DEF.at(j).at(k).at(1), conv_has_failed);			double max_value = string_to_double (DEF.at(j).at(k).at(2), conv_has_failed);			double value = string_to_double (actual_value, conv_has_failed);			if (is_in_range(min_value, max_value, value) && !conv_has_failed) return true;			else return false;		}	}	else {		if (actual_value == list_value) return true;		else return false;	}}

cDialog :: cDialog( double nposx, double nposy, string nidentifier, string ntext, DialogType dialogtype, Uint8 nmax_length /* = 20  */, unsigned int nmin_width ): cSprite( NULL, nposx, nposy ){	stext = NULL;		if( is_valid_number( ntext.c_str() ) ) 	{		text_number = string_to_int( ntext );	}	else	{		text_number = 0;	}	identifier.reserve( nidentifier.length() );	identifier = nidentifier;	text = ntext;		type = dialogtype;	boarder_in = 2;	boarder_out = 2;	text_area = 1;	min_width = nmin_width;		if( type != DIALOG_ONLY_NUMBERS )	{		if( nmax_length < ntext.length() ) 		{			max_length = ntext.length();		}		else		{			max_length = nmax_length;		}		text.reserve( max_length );	}	else	{		if( nmax_length < text_number ) 		{			max_length = text_number;		}		else		{			max_length = nmax_length;		}		text.reserve( 20 );	}		SetColors( colorDarkBlue, colorBlue, colorWhite, colorBlack );	Update_Boarders();	Update_Text();}

bool cRandom_Sound::Editor_Delay_Max_Text_Changed(const CEGUI::EventArgs& event){    const CEGUI::WindowEventArgs& windowEventArgs = static_cast<const CEGUI::WindowEventArgs&>(event);    std::string str_text = static_cast<CEGUI::Editbox*>(windowEventArgs.window)->getText().c_str();    Set_Delay_Max(string_to_int(str_text));    return 1;}

Status set_debug_level(const char *value){    int ivalue;    if (ERROR == string_to_int(value, &ivalue))        return ERROR;    else        _s_debug_level = ivalue;    return OK;}

static intglsl_dim_from_token(const string_const_t token) {	string_const_t dim;	size_t ofs = string_find(STRING_ARGS(token), '[', 0);	if (ofs == STRING_NPOS)		return 1;	++ofs;	dim = string_substr(STRING_ARGS(token), ofs, string_find(STRING_ARGS(token), ']', ofs) - ofs);	return string_to_int(STRING_ARGS(dim));}

void AssociateArray::load_data(const std::string & data, int method){    unsigned int pos = 0;    while (pos < data.size()) {        if (data[pos] == '/x00')            // probably EOF, NULL-byte due to encryption padding            break;        int start = pos;        while (data[pos] != ' ')            pos++;        int len = string_to_int(data.substr(start, pos-start));        pos++;        // read key        start = pos;        while (data[pos] != '/x00')            pos++;        std::string key = data.substr(start, pos-start);        decode_method(key, method);        pos++;        len -= key.size();        // read string        start = pos;        while (data[pos] != '/x00')            pos++;        std::string string = data.substr(start, pos-start);        decode_method(string, method);        pos++;        len -= string.size();        // read value        std::string value = data.substr(pos, len);        decode_method(value, method);        pos += len;        AssociateArrayItem & item = (*map)[key];        item.value = string_to_int(value);        item.string = string;    }}

int Usermanage::add_user(User user){    int found = this->find_user("name", user.get("name"));    if(found == -1){        if(this->is_same_name(user.get("name"))) return FAILED_NAME;        this->users.push_back(user);        this->active_user_amount++;        return NEW_USER;    }    else{        if(this->users[found].is_online()) return IS_ONLINE;        //if((user.get("name") != this->users[found].get("name")) && this->is_same_name(user.get("name"))) return FAILED_NAME;        this->users[found].online(string_to_int(user.get("fd")), string_to_int(user.get("port")), user.get("ip"));        this->active_user_amount++;        return OLD_USER;    }    return FAILED;}

static int parse_threshold_key(section_config_t *section, char *value){    if(!strcasecmp(value, "unlimited")) {        section->config.threshold = -1;    } else {        section->config.threshold = string_to_int(value);    }    return OMPI_SUCCESS;}

//handler para tratar CTRL + Cstatic void ctrlc_hand(int signo, siginfo_t *info, void *data) {    if (background == 1) {        return;     }    else {        Job job = vector_end(job_list);        if (job)            kill(string_to_int(job->pid), SIGINT);             }}