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

void InputControlListener::refreshSIP(){	pp_int32 i;	PPContainer* container = tracker.inputContainerExtended;	for (i = 0; i < (signed)sizeof(keyLine_0_lowerCase); i++)	{		PPButton* button = static_cast<PPButton*>(container->getControlByID(keyLineIDs_0[i]));		button->setText(uppercase() ? keyLine_0_lowerCase[i] : keyLine_0_upperCase[i]);	}	for (i = 0; i < (signed)sizeof(keyLine_1_lowerCase); i++)	{		PPButton* button = static_cast<PPButton*>(container->getControlByID(keyLineIDs_1[i]));		button->setText(uppercase() ? keyLine_1_lowerCase[i] : keyLine_1_upperCase[i]);	}	for (i = 0; i < (signed)sizeof(keyLine_2_lowerCase); i++)	{		PPButton* button = static_cast<PPButton*>(container->getControlByID(keyLineIDs_2[i]));		button->setText(uppercase() ? keyLine_2_lowerCase[i] : keyLine_2_upperCase[i]);	}	for (i = 0; i < (signed)sizeof(keyLine_3_lowerCase); i++)	{		PPButton* button = static_cast<PPButton*>(container->getControlByID(keyLineIDs_3[i]));		button->setText(uppercase() ? keyLine_3_lowerCase[i] : keyLine_3_upperCase[i]);	}	tracker.screen->paintControl(container);}

Haplotype* generate_haplotype(int32_t pos, Region& str_region, int32_t max_ref_flank_len, std::string& chrom_seq,			      std::vector<std::string>& vcf_alleles, StutterModel* stutter_model,			      std::vector<HapBlock*>& blocks, std::ostream& logger){  assert(blocks.size() == 0);  assert(vcf_alleles.size() >= 1);  int32_t rep_region_start   = pos;  int32_t rep_region_end     = rep_region_start + vcf_alleles[0].size();  int32_t min_start          = (rep_region_start < max_ref_flank_len ? 1 : rep_region_start-max_ref_flank_len);  int32_t max_stop           = rep_region_end + max_ref_flank_len;  assert(uppercase(vcf_alleles[0]).compare(uppercase(chrom_seq.substr(rep_region_start, rep_region_end-rep_region_start))) == 0);  // Create a set of haplotype regions, consisting of STR sequence block flanked by two reference sequence stretches  blocks.push_back(new HapBlock(min_start, rep_region_start, uppercase(chrom_seq.substr(min_start, rep_region_start-min_start))));   // Ref sequence preceding STRS  blocks.push_back(new RepeatBlock(rep_region_start, rep_region_end,                                   uppercase(chrom_seq.substr(rep_region_start, rep_region_end-rep_region_start)), str_region.period(), stutter_model));  blocks.push_back(new HapBlock(rep_region_end, max_stop, uppercase(chrom_seq.substr(rep_region_end, max_stop-rep_region_end))));    // Ref sequence following STRs  for (unsigned int j = 1; j < vcf_alleles.size(); j++)    blocks[1]->add_alternate(vcf_alleles[j]);  // Initialize each block's data structures, namely the homopolymer length information  for (unsigned int i = 0; i < blocks.size(); i++)    blocks[i]->initialize();  logger << "Constructing haplotype" << std::endl;  Haplotype* haplotype = new Haplotype(blocks);  haplotype->print_block_structure(30, 100, logger);  return haplotype;}

static int process_hostility(char *line){	int n;	char a[255], b[255];	int hostility;	int f1, f2;	n = sscanf(line, "hostility %[A-Za-z] %[A-Za-z] %d", a, b, &hostility);	if (n != 3)		return -1;	uppercase(a);	uppercase(b);	f1 = lookup_faction(a);	if (f1 < 0) {		fprintf(stderr, "Bad faction '%s'/n", a);		return -1;	}	f2 = lookup_faction(b);	if (f2 < 0) {		fprintf(stderr, "Bad faction '%s'/n", b);		return -1;	}	fact[f1].hostility[f2] = (float) hostility / 100.0f;	fact[f2].hostility[f1] = (float) hostility / 100.0f;	return 0;}

  void NEXUS::initialize()  {    // Check #NEXUS    getline(*file,line);    if (line != "#NEXUS")      throw myexception()<<"NEXUS trees reader: File does not begin with '#NEXUS' and may not be a NEXUS file.";      // [ and ] do not break words    string word;    bool in_trees_block=false;    while(get_NEXUS_command(*file,line))    {      //    cerr<<"line: "<<line<<endl;      int pos=0;            if (not get_word_NEXUS(word,pos,line)) continue;      //      cerr<<"NEXUS: command = :"<<word<<":"<<"     in_trees_block = "<<in_trees_block<<endl;            // Parse BEGIN TREES      if (uppercase(word) == "BEGIN") {	if (not get_word_NEXUS(word,pos,line)) continue;	if (uppercase(word) == "TREES")	  in_trees_block = true;      }            if (not in_trees_block) continue;            // Parse TRANSLATE ...      if (uppercase(word) == "TRANSLATE") {	parse_translate_command(line.substr(pos,line.size()-pos));	//      cerr<<"leaf names = "<<join(leaf_names,',')<<endl;	line.clear();	return;      }      else if (uppercase(word) == "TREE") {	try {	  get_word_NEXUS(word,pos,line);	  if (not (word == "="))	    get_word_NEXUS(word,pos,line);	  NEXUS_skip_ws(pos,line);	  SequenceTree T;	  string t = strip_NEXUS_comments(line.substr(pos,line.size()-pos));	  T.parse(t);	  leaf_names = T.get_sequences();	  std::sort(leaf_names.begin(),leaf_names.end());	  return;	}	catch (std::exception& e) {	  cerr<<" Error! "<<e.what()<<endl;	  cerr<<" Quitting read of tree file."<<endl;	  file->setstate(std::ios::badbit);	}      }    }  }

void CheckTimidityConfig(void){    if (*s_timiditycfgpath)        if (M_FileExists(s_timiditycfgpath))            C_Output("Using TiMidity configuration file %s.", uppercase(s_timiditycfgpath));        else            C_Warning("Can't find TiMidity configuration file %s.", uppercase(s_timiditycfgpath));}

int main (void){	char uppercase (char string[]);	char string[] = { "Test" };	char string2[] = { "THIS is THE second" };	char string3[] = { "abcdefghijklmnopqrstuvxyz" };	uppercase (string);	printf("/nTEST 1 i Test, o s/b TEST = %s/n", string);	uppercase (string2);	printf("/nTEST 2 i Test, o s/b THIS IS THE SECOND= %s/n", string2);	uppercase (string3);	printf("/nTEST 3 i Test, o s/b ABCDEFGHIJKLMNOPQRSTUVWXYZ = %s/n", string3);}

int main(void){char c;c = uppercase('a');printf("%c/n", c);c = uppercase('h');printf("%c/n", c);c = uppercase('A');printf("%c/n", c);c = uppercase('}');printf("%c/n", c);return (0);}

/** * version_string is defined in version.c adding it to a  * separate file allows us to parse it in configure.   */void display_version(BOOLEAN b) {     char name[128];  memset(name, 0, sizeof name);  strncpy(name, program_name, strlen(program_name));  if(b == TRUE){    printf("%s %s/n/n%s/n", uppercase(name, strlen(name)), version_string, copyright);    exit(EXIT_SUCCESS);  } else {    printf("%s %s/n", uppercase(name, strlen(name)), version_string);  }}

void addpet(Tree *pt){	Item temp;	if(TreeIsFull(pt)){		puts("No room in the club!");	}else{		puts("Please enter name of pet: ");		fgets(temp.petname,MAXN,stdin);		puts("Please enter kind of pet: ");		fgets(temp.petkind,MAXN,stdin);		uppercase(temp.petname);		uppercase(temp.petkind);		AddItem(&temp,pt);	}	}

static void codegen_ebml_union_content_from_type(struct_data *def,   char *name, int type, FILE *out) {  int i;  for (i = 0; i < def->info.member_count; i++) {    if (memb_struct_check(&def->info.members[i])) {      char uppercased[strlen(def->info.members[i].type_info.substruct_info.type_name)+1];      uppercase(def->info.members[i].type_info.substruct_info.type_name,uppercased);      fprintf(out,"    case %d: {/n",i);      fprintf(out,"      uber.actual = &(actual->%s);/n      ",        def->info.members[i].name);      if (type) {        fprintf(out,"uber.type = EBML_%s;/n",uppercased);        fprintf(out,"      res += info_pack_to_ebml(&ebml[res],&uber);/n");      } else {        fprintf(out,"uber.type = DEBML_%s;/n",uppercased);        fprintf(out,"      res += info_unpack_fr_ebml(&ebml[res],&uber);/n");      }      fprintf(out,"      break;/n    }/n");    }    /* TODO: handle unions of primitives (ints,floats,strings...) */  }          return;}

LCUI_API int LCUI_strcasecmpW( const wchar_t *str1, const wchar_t *str2 ){	const wchar_t *p1, *p2;	for(p1=str1, p2=str2; *p1!=0 || *p2!=0; ++p1, ++p2) {		if(uppercase(*p1) == uppercase(*p2)) {			continue;		}		return *p1-*p2;	}	if( *p1 != 0 ) {		return 1;	} else if( *p2 != 0 ) {		return -1;	}	return 0;}

void main(){clrscr();int choice;char ch;do{clrscr();cout<<"/n MENU ";cout<<"/n 1.CREATE";cout<<"/n 2.DISPLAY";cout<<"/n 3.NO OF UPPER CASE CHARACTERS ";cout<<"/n 4.NO OF VOWELS";cout<<"/n 5.NO OF DIGITS";cout<<"/n 6.NO OF WORDS";cout<<"/n 7.NUMBER OF LINES";cout<<"/n enter ur choice";cin>>choice;switch(choice){case 1:create();break;case 2:display();break;case 3:uppercase();break;case 4:vowels();break;case 5:digits();break;case 6:words();break;case 7:lines();break;default: cout<<"/n wrong choice entered..!!";}cout<<"/n do you want to continue...??";cin>>ch;}while(ch=='y'||ch=='Y');}

void addpet(Tree * pt){	Item temp;		if(TreeIsFull(pt)){		puts("No room in the club");	}	else{		puts("Please enter name of pet");		gets(temp.petname);		puts("please enter pet kind");		gets(temp.petkind);		uppercase(temp.petname);		uppercase(temp.petkind);		AddItem(&temp,pt);	}}

/* ----------------------------------------------------------------------------*/char* programaDisciplina(char* disc){        FILE *fd;    char texto[10];    string str;    /* Normaliza e obtem o nome do arquivo correspondente     * a disciplina passada como parametro*/    uppercase(disc);    strcpy(texto, disc);    strcat(texto, ".txt");    fd = fopen(texto, "r");    /* Verifica se a abertura do arquivo foi bem sucedida */    if(fd == NULL){        printf("Erro ao abrir o arquivo da disciplina %s./n", disc);        exit(-1);    }    else{        char tmp[200];        char *pch;        /* Inicializa um vetor contendo a resposta */        str = str_initialize(((size_t)NUM_MAX_DISCIPLINAS * TAM_MAX_NOME_DISCIPLINA));                /* Le o titulo da disciplina */        fgets(tmp, sizeof(tmp), fd);        str_concat_chararr(str, tmp, sizeof(tmp) -1);        /* Le o resto do arquivo */        while(fgets(tmp, sizeof(tmp), fd)!=NULL){            /* Separa a linha lida */            pch = strtok(tmp, " ");            /* Imprime a linha lida */            while(pch !=NULL){                /* Para a impressao caso se depare com a palavra "Horário:" */                                if(strcmp(pch, "Horário:/n") ==0){                    str_concat_chararr(str, "/n", sizeof(char));                    fclose(fd);                    return str->s;                }                else{                    str_concat_chararr(str, pch, strlen(pch));                    str_concat_chararr(str, " ", sizeof(char));                }                pch = strtok(NULL, " ");                                            }                    }        str_concat_chararr(str, "/n", sizeof(char));        fclose(fd);        return str->s;    }}

  bool NEXUS::next_tree_(Tree& T,int& r)  {    if (not line.size())      get_NEXUS_command(*file,line);    if (not line.size()) return false;    try {      string word;      int pos=0;      get_word_NEXUS(word,pos,line);      if (uppercase(word) == "END") {	file->setstate(std::ios::badbit);	return false;      }      get_word_NEXUS(word,pos,line);      if (not (word == "=")) {	get_word_NEXUS(word,pos,line);	assert(word == "=");      }      NEXUS_skip_ws(pos,line);            string t = strip_NEXUS_comments(line.substr(pos,line.size()-pos));      if (leaf_names.size())	r = T.parse_with_names(t, leaf_names);      else	r = T.parse_no_names(t);    }    catch (std::exception& e) {      cerr<<" Error! "<<e.what()<<endl;      cerr<<" Quitting read of tree file."<<endl;      file->setstate(std::ios::badbit);      return false;    }    line.clear();    return not done();  }

int main (void) {    int caractere,        ultimaFoiMaiuscula = 0;    while (caractere = getc(stdin), caractere != EOF) {        if (ehLetra(caractere)) {            if (ultimaFoiMaiuscula) {                putc(lowercase(caractere), stdout);            }            else {                putc(uppercase(caractere), stdout);            }            ultimaFoiMaiuscula = !ultimaFoiMaiuscula;        }        else {            putc(caractere, stdout);        }        if (caractere == '/n') {            ultimaFoiMaiuscula = 0;        }    }    return 0;}

// MS SQL 2000char *msql2k (char *pwd, char *salt) {  static char sql2k[128];  SHA_CTX ctx;  char    uc[128];  wchar_t wcs[128];  uint8_t sbin[32], out[32];  size_t  plen, slen;  int     i, idx=0;    idx=init_entry (sql2k, salt, sbin, 1);    // convert to uppercase  uppercase (uc, pwd);  // convert password to Unicode  plen=mbstowcs (wcs, uc, sizeof wcs);    // hash with salt  SHA1_Init (&ctx);  SHA1_Update (&ctx, wcs, plen*2);  SHA1_Update (&ctx, sbin, idx - VERSION_LEN);  SHA1_Final (out, &ctx);    // format to hex  for (i=0; i<SHA_DIGEST_LENGTH; i++) {    _snprintf (&sql2k[(idx+i)*2], 2, "%02X", out[i]);  }  return sql2k;}

void displaymap(unsigned char c, char *buf){    buf[0] = '^';    if (IS_CTRL(c))        buf[1] = c + 64;    else        buf[1] = uppercase(c);}

/* ------------------------------------------------------------------------*//** * @FUNCTION		main44xx_write * @BRIEF		write selected item provided in string argv. * @RETURNS		0 in case of success *			OMAPCONF_ERR_ARG *			OMAPCONF_ERR_CPU *			OMAPCONF_ERR_REG_ACCESS *			OMAPCONF_ERR_INTERNAL * @param[in]		argc: shell input argument number * @param[in]		argv: shell input argument(s) * @DESCRIPTION		write selected item provided in string argv. *//*------------------------------------------------------------------------ */static int main44xx_write(int argc, char *argv[]){	CHECK_CPU(44xx, OMAPCONF_ERR_CPU);	if (strcmp(argv[0], "audioic") == 0) {		if (argc < 3) {			return err_arg_missing_msg_show(HELP_CATEGORY_MAX);		} else if (argc == 3) {			return twl6040_writereg(				uppercase(argv[1]), uppercase(argv[2]));		} else {			return err_arg_too_many_msg_show(HELP_CATEGORY_MAX);		}	} else {		return err_unknown_argument_msg_show(argv[0]);	}}

/*  convert a letter to upper case */char *uppercase_string(char * s){	int i = 0;	while (	*(s+i) != '/0' ){		*(s+i) = uppercase ( *(s+i) );		i +=1;	}	return s;}

void R_InitColormaps(void){    dboolean    COLORMAP = (W_CheckMultipleLumps("COLORMAP") > 1);    int         i;    byte        *palsrc, *palette;    wad_file_t  *colormapwad;    if (W_CheckNumForName("C_START") >= 0 && W_CheckNumForName("C_END") >= 0)    {        firstcolormaplump = W_GetNumForName("C_START");        lastcolormaplump = W_GetNumForName("C_END");        numcolormaps = lastcolormaplump - firstcolormaplump;        colormaps = Z_Malloc(sizeof(*colormaps) * numcolormaps, PU_STATIC, NULL);        colormaps[0] = W_CacheLumpName("COLORMAP", PU_STATIC);        for (i = 1; i < numcolormaps; i++)            colormaps[i] = W_CacheLumpNum(i + firstcolormaplump, PU_STATIC);    }    else    {        colormaps = Z_Malloc(sizeof(*colormaps), PU_STATIC, NULL);        colormaps[0] = W_CacheLumpName("COLORMAP", PU_STATIC);    }    colormapwad = lumpinfo[W_CheckNumForName("COLORMAP")]->wad_file;    C_Output("Using the COLORMAP lump in %s file %s.",        (colormapwad->type == IWAD ? "IWAD" : "PWAD"), uppercase(colormapwad->path));    // [BH] There's a typo in dcolors.c, the source code of the utility Id    // Software used to construct the palettes and colormaps for DOOM (see    // http://www.doomworld.com/idgames/?id=16644). When constructing colormap    // 32, which is used for the invulnerability powerup, the traditional    // Y luminance values are used (see http://en.wikipedia.org/wiki/YIQ), but a    // value of 0.144 is used when it should be 0.114. So I've grabbed the    // offending code from dcolor.c, corrected it, put it here, and now colormap    // 32 is manually calculated rather than grabbing it from the colormap lump.    // The resulting differences are minor.    palsrc = palette = W_CacheLumpName("PLAYPAL", PU_CACHE);    for (i = 0; i < 255; i++)    {        float       red = *palsrc++ / 256.0f;        float       green = *palsrc++ / 256.0f;        float       blue = *palsrc++ / 256.0f;        float       gray = red * 0.299f + green * 0.587f + blue * 0.114f/*0.144f*/;        grays[i] = FindNearestColor(palette, (int)(gray * 255.0f),            (int)(gray * 255.0f), (int)(gray * 255.0f));        if (!COLORMAP)        {            gray = (1.0f - gray) * 255.0f;            colormaps[0][32 * 256 + i] = FindNearestColor(palette, (int)gray, (int)gray, (int)gray);        }    }}

JNIEXPORT jstring JNICALL Java_Sample1_stringMethod(JNIEnv* env, jobject obj, jstring string) {    const char* str = env->GetStringUTFChars(string, 0);    char cap[128];    strcpy(cap, str);    env->ReleaseStringUTFChars(string, str);    uppercase(cap);    return env->NewStringUTF(cap);}

int Register::getReg(string regName) {	string key = uppercase(regName);	bool isExist = regs.count(key) > 0;	if (!isExist) {		regs[key] = 0;	}	return regs[key];}

int GetBoolean(){    if (!IsBoolean(Look)) {        Expected("Boolean Literal");    }    int ret = uppercase(Look) == 'T';    GetChar();    return ret;}

static voidtstate_to_text(uint_t tstate, uint_t paniced, char *out, size_t out_sz){	if (paniced)		mdb_snprintf(out, out_sz, "panic");	else		thread_state_to_text(tstate, out, out_sz);	uppercase(out);}

int main(){  char *lib_file = "./build/libex29.so";  void *lib = dlopen(lib_file, RTLD_NOW);  check(lib != NULL, "Failed to open library %s: %s", lib_file, dlerror());  lib_function func;  int success;  char *test_string = "Hello! This is Mission Control!";  int test_string_length = strlen(test_string);  char *lower_string = malloc(sizeof(char) * test_string_length);  func = dlsym(lib, "lowercase");  func(lower_string, test_string, test_string_length);  success = strncmp(lower_string, "hello! this is mission control!", test_string_length);  check(success == 0,        "(dynamic) Lower Case failed: %s -> %s",        test_string,        lower_string       );  char *upper_string = malloc(sizeof(char) * test_string_length);  func = dlsym(lib, "uppercase");  func(upper_string, test_string, test_string_length);  success = strncmp(upper_string, "HELLO! THIS IS MISSION CONTROL!", test_string_length);  check(success == 0,        "(dynamic) Upper Case failed: %s -> %s",        test_string,        upper_string       );  free(lower_string);  free(upper_string);  lower_string = malloc(sizeof(char) * test_string_length);  lowercase(lower_string, test_string, test_string_length);  success = strncmp(lower_string, "hello! this is mission control!", test_string_length);  check(success == 0,        "(static) Lower Case failed: %s -> %s",        test_string,        lower_string       );  upper_string = malloc(sizeof(char) * test_string_length);  uppercase(upper_string, test_string, test_string_length);  success = strncmp(upper_string, "HELLO! THIS IS MISSION CONTROL!", test_string_length);  check(success == 0,        "(static) Upper Case failed: %s -> %s",        test_string,        upper_string       );  return 0;error:  return 1;}

static int mod_uppercase(char *buf, size_t len){	char tmp[EXPAND_BUFFER];	if (! uppercase(tmp, buf, sizeof tmp))		return 0;	if (strlcpy(buf, tmp, len) >= len)		return 0;	return 1;}

int main(){    char *none = 0;    static char *strings[] = {"apple", "banana", "carrot", "daikon",			      "eggplant", "fig", "grape", 0 };    f(strings[1], strings);    uppercase("huckleberry");    return 0;}