Function help - Character Arrays.

[zachb]

In pig-latin if the word starts with a constonant, then all the letters of that word up to a vowel are added to the end.

nerds -> erds-nay
shake -> ake-shay
translate -> anslate-tray

I made this code to do this. Could someone look over it as I really havnt had much practice with arrays and cstring.

void con_PLatin (char word[], const int length)
{
  char temp[20];
  char tempword[25];
  char chartemp;
  int i = 1; 
  int j = 0;
  int a = 0;
  int length_tempword;
  
  chartemp = word[0];
  strcopy (temp, chartemp);
  
  do 
  {
    
	if (strchr("bcdfghjklmnpqrstvwxyz", word[i])
	{ 
      chartemp = word[i];
	  strcat (temp, chartemp);
	  i++;
    }
  }	while(strchr("bcdfghjklmnpqrstvwxyz", word[i]);

  do
  {
    tempword[j] = word[j];
	j++;
  }while (j < length);
  
  length_tempword = strlen(tempword);
  
  do 
  { 
    word[a] = tempword [a];
	a ++ 
  } while (a < length_tempword);
  
  strcat (word, "-");
  strcat (word, temp);
  strcat (word, "ay");
 
  return;
}

Does it look good? Any changes or recommendations to make it better (without using more complex C++) ?

[justin0108]

Hi

I would prefer to use string instead of char array

#include <string>
#include <iostream>

using namespace std;

int main( void )
{
	string vowels = "aeiou";
	string englishWord = "translate";
	string latinWord = "";

	if ( englishWord.find(vowels) )
	{		
		latinWord = englishWord.substr( englishWord.find_first_of(vowels), englishWord.length() ) +
					"-" +
					englishWord.substr( 0, englishWord.find_first_of(vowels) ) +
					"ay";
	}
	
	cout << latinWord << endl;
	return 0;
}

Just something simple to demonstrate the idea. Might not be the best method

[Twey]

You can make it a lot easier on yourself by using std::string from the standard library. Also, there's another rule you missed: a word starting with a vowel simply gets ‘-way’ appended. For example, ‘eagle’ becomes ‘eagleway’:

#include <cstring>
#include <string>
#include <iostream>

inline bool is_vowel(char ch) {
  return strchr("aeiou", ch);
}

std::string con_PLatin(const std::string word) {
  std::string lead, rest;

  for (int i = 0; i < word.length(); ++i)
    if (is_vowel(word[i])) {
      lead = word.substr(0, i);
      rest = word.substr(i, word.length());
      break;
    }

  return rest + (lead.empty() ? "way" : lead + "ay");
}

If you want to be able to pass C-strings, just overload to convert:

const char* con_PLatin(const char* word) {
  return con_PLatin(std::string(word)).c_str();
}

(Haskell:

import Data.List (break)
import System (getArgs, getProgName)

main = getArgs >>= doPigLatin

doPigLatin [] = do progName <- getProgName
                   putStrLn $ "Usage: " ++ progName ++ " <word>"
doPigLatin wrds = putStr . unlines . map pigLatin $ wrds

pigLatin word = let (lead, rest) = break isVowel word
                 in rest ++ (if lead == "" then "way" else lead ++ "ay")
  where isVowel = (`elem` "aeiou")

)

Edit: surely there's some easy way to get rid of that annoying ‘const’ on the char* overload? Something like:

char *copy_string(const char* str) {
  char ret[strlen(str)];
  strcpy(ret, str);
  return ret;
}

?

Further edit: aha — I found it:

char* con_PLatin(const char* word) {
  return const_cast<char *>(con_PLatin(std::string(word)).c_str());
}

Since the resultant std::string is discarded, that should be safe, right?