diff --git a/README.md b/README.md
index fd3c725..32a9a08 100644
--- a/README.md
+++ b/README.md
@@ -105,7 +105,7 @@ As a result libargparse also supports custom conversions, allowing user-defined
 If we wanted to modify the above example so the '--bar' argument accepted the strings 'on' and 'off' (instead of the default 'true' and 'false') we would define a custom class as follows:
 ```cpp
 struct OnOff {
-    ConvertedValue<bool> from_str(std::string str) {
+    ConvertedValue<bool> from_str(const std::string& str) {
         ConvertedValue<bool> converted_value;
 
         if      (str == "on")  converted_value.set_value(true);
diff --git a/argparse_example.cpp b/argparse_example.cpp
index a61c974..3d566e7 100644
--- a/argparse_example.cpp
+++ b/argparse_example.cpp
@@ -15,7 +15,7 @@ struct Args {
 };
 
 struct OnOff {
-    ConvertedValue<bool> from_str(std::string str) {
+    ConvertedValue<bool> from_str(const std::string& str) {
         ConvertedValue<bool> converted_value;
 
         if      (str == "on")  converted_value.set_value(true);
@@ -37,7 +37,7 @@ struct OnOff {
 };
 
 struct ZeroOneRange {
-    ConvertedValue<float> from_str(std::string str) {
+    ConvertedValue<float> from_str(const std::string& str) {
         float value;
         std::stringstream ss(str);
         ss >> value;
diff --git a/argparse_test.cpp b/argparse_test.cpp
index d1a1bf1..d836152 100644
--- a/argparse_test.cpp
+++ b/argparse_test.cpp
@@ -91,11 +91,11 @@ struct Args {
     ArgValue<std::vector<float>> zero_or_more;
 };
 
-bool expect_pass(argparse::ArgumentParser& parser, std::vector<std::string> cmd_line);
-bool expect_fail(argparse::ArgumentParser& parser, std::vector<std::string> cmd_line);
+bool expect_pass(argparse::ArgumentParser& parser, const std::vector<std::string>& cmd_line);
+bool expect_fail(argparse::ArgumentParser& parser, const std::vector<std::string>& cmd_line);
 
 struct OnOff {
-    ConvertedValue<bool> from_str(std::string str) {
+    ConvertedValue<bool> from_str(const std::string& str) {
         ConvertedValue<bool> converted_value;
 
         if      (str == "on")  converted_value.set_value(true);
@@ -549,7 +549,7 @@ int main(
 #endif
 }
 
-bool expect_pass(argparse::ArgumentParser& parser, std::vector<std::string> cmd_line) {
+bool expect_pass(argparse::ArgumentParser& parser, const std::vector<std::string>& cmd_line) {
     try {
         parser.parse_args_throw(cmd_line);
     } catch(const argparse::ArgParseHelp&) {
@@ -566,7 +566,7 @@ bool expect_pass(argparse::ArgumentParser& parser, std::vector<std::string> cmd_
     return true;
 }
 
-bool expect_fail(argparse::ArgumentParser& parser, std::vector<std::string> cmd_line) {
+bool expect_fail(argparse::ArgumentParser& parser, const std::vector<std::string>& cmd_line) {
     try {
         parser.parse_args_throw(cmd_line);
     } catch(const argparse::ArgParseError& err) {
diff --git a/src/argparse.cpp b/src/argparse.cpp
index c1d9717..f0e2f7f 100644
--- a/src/argparse.cpp
+++ b/src/argparse.cpp
@@ -16,7 +16,7 @@ namespace argparse {
      * ArgumentParser
      */
 
-    ArgumentParser::ArgumentParser(std::string prog_name, std::string description_str, std::ostream& os)
+    ArgumentParser::ArgumentParser(const std::string& prog_name, const std::string& description_str, std::ostream& os)
         : description_(description_str)
         , formatter_(new DefaultFormatter())
         , os_(os)
@@ -25,7 +25,7 @@ namespace argparse {
         argument_groups_.push_back(ArgumentGroup("arguments"));
     }
 
-    ArgumentParser& ArgumentParser::prog(std::string prog_name, bool basename_only) {
+    ArgumentParser& ArgumentParser::prog(const std::string& prog_name, bool basename_only) {
         if (basename_only) {
             prog_ = basename(prog_name);
         } else {
@@ -34,17 +34,17 @@ namespace argparse {
         return *this;
     }
 
-    ArgumentParser& ArgumentParser::version(std::string version_str) {
+    ArgumentParser& ArgumentParser::version(const std::string& version_str) {
         version_ = version_str;
         return *this;
     }
 
-    ArgumentParser& ArgumentParser::epilog(std::string epilog_str) {
+    ArgumentParser& ArgumentParser::epilog(const std::string& epilog_str) {
         epilog_ = epilog_str;
         return *this;
     }
 
-    ArgumentGroup& ArgumentParser::add_argument_group(std::string description_str) {
+    ArgumentGroup& ArgumentParser::add_argument_group(const std::string& description_str) {
         argument_groups_.push_back(ArgumentGroup(description_str));
         return argument_groups_[argument_groups_.size() - 1];
     }
@@ -78,7 +78,7 @@ namespace argparse {
         parse_args_throw(arg_strs);
     }
     
-    void ArgumentParser::parse_args_throw(std::vector<std::string> arg_strs) {
+    void ArgumentParser::parse_args_throw(const std::vector<std::string>& arg_strs) {
         add_help_option_if_unspecified();
 
         //Reset all the defaults
@@ -373,7 +373,7 @@ namespace argparse {
         }
     }
 
-    ArgumentParser::ShortArgInfo ArgumentParser::no_space_short_arg(std::string str, const std::map<std::string, std::shared_ptr<Argument>>& str_to_option_arg) const {
+    ArgumentParser::ShortArgInfo ArgumentParser::no_space_short_arg(const std::string& str, const std::map<std::string, std::shared_ptr<Argument>>& str_to_option_arg) const {
 
         ShortArgInfo short_arg_info;
         for(const auto& kv : str_to_option_arg) {
@@ -409,11 +409,11 @@ namespace argparse {
     /*
      * ArgumentGroup
      */
-    ArgumentGroup::ArgumentGroup(std::string name_str)
+    ArgumentGroup::ArgumentGroup(const std::string& name_str)
         : name_(name_str)
         {}
 
-    ArgumentGroup& ArgumentGroup::epilog(std::string str) {
+    ArgumentGroup& ArgumentGroup::epilog(const std::string& str) {
         epilog_ = str;
         return *this;
     }
@@ -424,7 +424,7 @@ namespace argparse {
     /*
      * Argument
      */
-    Argument::Argument(std::string long_opt, std::string short_opt)
+    Argument::Argument(const std::string& long_opt, const std::string& short_opt)
         : long_opt_(long_opt)
         , short_opt_(short_opt) {
 
@@ -444,7 +444,7 @@ namespace argparse {
         metavar_ = toupper(dashes_name[1]);
     }
 
-    Argument& Argument::help(std::string help_str) {
+    Argument& Argument::help(const std::string& help_str) {
         help_ = help_str;
         return *this;
     }
@@ -475,12 +475,12 @@ namespace argparse {
         return *this;
     }
 
-    Argument& Argument::metavar(std::string metavar_str) {
+    Argument& Argument::metavar(const std::string& metavar_str) {
         metavar_ = metavar_str;
         return *this;
     }
 
-    Argument& Argument::choices(std::vector<std::string> choice_values) {
+    Argument& Argument::choices(const std::vector<std::string>& choice_values) {
         choices_ = choice_values;
         return *this;
     }
@@ -535,7 +535,7 @@ namespace argparse {
         return default_value(std::vector<std::string>(values.begin(), values.end()));
     }
 
-    Argument& Argument::group_name(std::string grp) {
+    Argument& Argument::group_name(const std::string& grp) {
         group_name_ = grp;
         return *this;
     }
diff --git a/src/argparse.hpp b/src/argparse.hpp
index 652ccdb..7066455 100644
--- a/src/argparse.hpp
+++ b/src/argparse.hpp
@@ -34,35 +34,35 @@ namespace argparse {
     class ArgumentParser {
         public:
             //Initializes an argument parser
-            ArgumentParser(std::string prog_name, std::string description_str=std::string(), std::ostream& os=std::cout);
+            ArgumentParser(const std::string& prog_name, const std::string& description_str=std::string(), std::ostream& os=std::cout);
 
             //Overrides the program name
-            ArgumentParser& prog(std::string prog, bool basename_only=true);
+            ArgumentParser& prog(const std::string& prog, bool basename_only=true);
 
             //Sets the program version
-            ArgumentParser& version(std::string version);
+            ArgumentParser& version(const std::string& version);
 
             //Specifies the epilog text at the bottom of the help description
-            ArgumentParser& epilog(std::string prog);
+            ArgumentParser& epilog(const std::string& prog);
 
             //Adds an argument or option with a single name (single value)
             template<typename T, typename Converter=DefaultConverter<T>>
-            Argument& add_argument(ArgValue<T>& dest, std::string option);
+            Argument& add_argument(ArgValue<T>& dest, const std::string& option);
 
             //Adds an option with a long and short option name (single value)
             template<typename T, typename Converter=DefaultConverter<T>>
-            Argument& add_argument(ArgValue<T>& dest, std::string long_opt, std::string short_opt);
+            Argument& add_argument(ArgValue<T>& dest, const std::string& long_opt, const std::string& short_opt);
 
             //Adds an argument or option with a single name (multi value)
             template<typename T, typename Converter=DefaultConverter<T>>
-            Argument& add_argument(ArgValue<std::vector<T>>& dest, std::string option);
+            Argument& add_argument(ArgValue<std::vector<T>>& dest, const std::string& option);
 
             //Adds an option with a long and short option name (multi value)
             template<typename T, typename Converter=DefaultConverter<T>>
-            Argument& add_argument(ArgValue<std::vector<T>>& dest, std::string long_opt, std::string short_opt);
+            Argument& add_argument(ArgValue<std::vector<T>>& dest, const std::string& long_opt, const std::string& short_opt);
 
             //Adds a group to collect related arguments
-            ArgumentGroup& add_argument_group(std::string description_str);
+            ArgumentGroup& add_argument_group(const std::string& description_str);
 
             //Like parse_arg_throw(), but catches exceptions and exits the program
             void parse_args(int argc, const char* const* argv, int error_exit_code=1, int help_exit_code=0, int version_exit_code=0);
@@ -72,7 +72,7 @@ namespace argparse {
             //If an error occurs throws ArgParseError
             //If an help is requested occurs throws ArgParseHelp
             void parse_args_throw(int argc, const char* const* argv);
-            void parse_args_throw(std::vector<std::string> args);
+            void parse_args_throw(const std::vector<std::string>& args);
 
             //Reset the target values to their initial state
             void reset_destinations();
@@ -108,7 +108,7 @@ namespace argparse {
                 std::shared_ptr<argparse::Argument> arg;
                 std::string value;
             };
-            ShortArgInfo no_space_short_arg(std::string str, const std::map<std::string, std::shared_ptr<Argument>>& str_to_option_arg) const;
+            ShortArgInfo no_space_short_arg(const std::string& str, const std::map<std::string, std::shared_ptr<Argument>>& str_to_option_arg) const;
         private:
             std::string prog_;
             std::string description_;
@@ -126,22 +126,22 @@ namespace argparse {
 
             //Adds an argument or option with a single name (single value)
             template<typename T, typename Converter=DefaultConverter<T>>
-            Argument& add_argument(ArgValue<T>& dest, std::string option);
+            Argument& add_argument(ArgValue<T>& dest, const std::string& option);
 
             //Adds an option with a long and short option name (single value)
             template<typename T, typename Converter=DefaultConverter<T>>
-            Argument& add_argument(ArgValue<T>& dest, std::string long_opt, std::string short_opt);
+            Argument& add_argument(ArgValue<T>& dest, const std::string& long_opt, const std::string& short_opt);
 
             //Adds an argument or option with a multi name (multi value)
             template<typename T, typename Converter=DefaultConverter<T>>
-            Argument& add_argument(ArgValue<std::vector<T>>& dest, std::string option);
+            Argument& add_argument(ArgValue<std::vector<T>>& dest, const std::string& option);
 
             //Adds an option with a long and short option name (multi value)
             template<typename T, typename Converter=DefaultConverter<T>>
-            Argument& add_argument(ArgValue<std::vector<T>>& dest, std::string long_opt, std::string short_opt);
+            Argument& add_argument(ArgValue<std::vector<T>>& dest, const std::string& long_opt, const std::string& short_opt);
 
             //Adds an epilog to the group
-            ArgumentGroup& epilog(std::string str);
+            ArgumentGroup& epilog(const std::string& str);
 
         public:
             //Returns the name of the group
@@ -159,7 +159,7 @@ namespace argparse {
             ArgumentGroup& operator=(const ArgumentGroup&&) = delete;
         private:
             friend class ArgumentParser;
-            ArgumentGroup(std::string name_str=std::string());
+            ArgumentGroup(const std::string& name_str=std::string());
         private:
             std::string name_;
             std::string epilog_;
@@ -168,12 +168,12 @@ namespace argparse {
 
     class Argument {
         public:
-            Argument(std::string long_opt, std::string short_opt);
+            Argument(const std::string& long_opt, const std::string& short_opt);
         public: //Configuration Mutators
             //Sets the hlep text
-            Argument& help(std::string help_str);
+            Argument& help(const std::string& help_str);
 
-            //Sets the defuault value
+            //Sets the default value
             Argument& default_value(const std::string& default_val);
             Argument& default_value(const std::vector<std::string>& default_val);
             Argument& default_value(const std::initializer_list<std::string>& default_val);
@@ -185,16 +185,16 @@ namespace argparse {
             Argument& required(bool is_required);
 
             //Sets the associated metavar (if not specified, inferred from argument name, or choices)
-            Argument& metavar(std::string metavar_sr);
+            Argument& metavar(const std::string& metavar_sr);
 
             //Sets the expected number of arguments
             Argument& nargs(char nargs_type);
 
             //Sets the valid choices for this option's value
-            Argument& choices(std::vector<std::string> choice_values);
+            Argument& choices(const std::vector<std::string>& choice_values);
 
             //Sets the group name this argument is associated with
-            Argument& group_name(std::string grp);
+            Argument& group_name(const std::string& grp);
 
             //Sets where this option appears in the help
             Argument& show_in(ShowIn show);
@@ -204,10 +204,10 @@ namespace argparse {
             virtual void set_dest_to_default() = 0;
 
             //Sets the target value to the specified value
-            virtual void set_dest_to_value(std::string value) = 0;
+            virtual void set_dest_to_value(const std::string& value) = 0;
 
             //Adds the specified value to the taget values
-            virtual void add_value_to_dest(std::string value) = 0;
+            virtual void add_value_to_dest(const std::string& value) = 0;
 
             //Set the target value to true
             virtual void set_dest_to_true() = 0;
@@ -264,7 +264,7 @@ namespace argparse {
             bool default_set() const;
 
             //Returns true if the proposed value is legal
-            virtual bool is_valid_value(std::string value) = 0;
+            virtual bool is_valid_value(const std::string& value) = 0;
         public: //Lifetime
             virtual ~Argument() {}
             Argument(const Argument&) = default;
@@ -294,7 +294,7 @@ namespace argparse {
     template<typename T, typename Converter>
     class SingleValueArgument : public Argument {
         public: //Constructors
-            SingleValueArgument(ArgValue<T>& dest, std::string long_opt, std::string short_opt)
+            SingleValueArgument(ArgValue<T>& dest, const std::string& long_opt, const std::string& short_opt)
                 : Argument(long_opt, short_opt)
                 , dest_(dest)
                 {}
@@ -305,7 +305,7 @@ namespace argparse {
                 dest_.set_argument_group(group_name());
             }
 
-            void set_dest_to_value(std::string value) override {
+            void set_dest_to_value(const std::string& value) override {
                 if (dest_.provenance() == Provenance::SPECIFIED
                     && dest_.argument_name() == name()) {
                     throw ArgParseError("Argument " + name() + " specified multiple times");
@@ -316,7 +316,7 @@ namespace argparse {
                 dest_.set_argument_group(group_name());
             }
 
-            void add_value_to_dest(std::string /*value*/) override {
+            void add_value_to_dest(const std::string& /*value*/) override {
                 throw ArgParseError("Single value option can not have multiple values set");
             }
 
@@ -347,7 +347,7 @@ namespace argparse {
                 dest_ = ArgValue<T>();
             }
 
-            bool is_valid_value(std::string value) override {
+            bool is_valid_value(const std::string& value) override {
                 auto converted_value = Converter().from_str(value);
 
                 if (!converted_value) {
@@ -364,7 +364,7 @@ namespace argparse {
     template<typename Converter>
     class SingleValueArgument<bool,Converter> : public Argument {
         public: //Constructors
-            SingleValueArgument(ArgValue<bool>& dest, std::string long_opt, std::string short_opt)
+            SingleValueArgument(ArgValue<bool>& dest, const std::string& long_opt, const std::string& short_opt)
                 : Argument(long_opt, short_opt)
                 , dest_(dest)
                 {}
@@ -375,11 +375,11 @@ namespace argparse {
                 dest_.set_argument_group(group_name());
             }
 
-            void add_value_to_dest(std::string /*value*/) override {
+            void add_value_to_dest(const std::string& /*value*/) override {
                 throw ArgParseError("Single value option can not have multiple values set");
             }
 
-            void set_dest_to_value(std::string value) override {
+            void set_dest_to_value(const std::string& value) override {
                 if (dest_.provenance() == Provenance::SPECIFIED
                     && dest_.argument_name() == name()) {
                     throw ArgParseError("Argument " + name() + " specified multiple times");
@@ -417,7 +417,7 @@ namespace argparse {
                 dest_ = ArgValue<bool>();
             }
 
-            bool is_valid_value(std::string value) override {
+            bool is_valid_value(const std::string& value) override {
                 auto converted_value = Converter().from_str(value);
 
                 if (!converted_value) {
@@ -432,7 +432,7 @@ namespace argparse {
     template<typename T, typename Converter>
     class MultiValueArgument : public Argument {
         public: //Constructors
-            MultiValueArgument(ArgValue<T>& dest, std::string long_opt, std::string short_opt)
+            MultiValueArgument(ArgValue<T>& dest, const std::string& long_opt, const std::string& short_opt)
                 : Argument(long_opt, short_opt)
                 , dest_(dest)
                 {}
@@ -449,11 +449,11 @@ namespace argparse {
                 dest_.set_argument_group(group_name());
             }
 
-            void set_dest_to_value(std::string /*value*/) override {
+            void set_dest_to_value(const std::string& /*value*/) override {
                 throw ArgParseError("Multi-value option can not be set to a single value");
             }
 
-            void add_value_to_dest(std::string value) override {
+            void add_value_to_dest(const std::string& value) override {
                 if (dest_.provenance() == Provenance::SPECIFIED
                     && dest_.argument_name() != name()) {
                     throw ArgParseError("Argument destination already set by " + dest_.argument_name() + " (trying to set from " + name() + ")");
@@ -497,7 +497,7 @@ namespace argparse {
                 dest_ = ArgValue<T>();
             }
 
-            bool is_valid_value(std::string value) override {
+            bool is_valid_value(const std::string& value) override {
                 auto converted_value = Converter().from_str(value);
 
                 if (!converted_value) {
diff --git a/src/argparse.tpp b/src/argparse.tpp
index d908493..00a824f 100644
--- a/src/argparse.tpp
+++ b/src/argparse.tpp
@@ -4,7 +4,7 @@
 namespace argparse {
 
     template<typename T, typename Converter>
-    std::shared_ptr<Argument> make_singlevalue_argument(ArgValue<T>& dest, std::string long_opt, std::string short_opt) {
+    std::shared_ptr<Argument> make_singlevalue_argument(ArgValue<T>& dest, const std::string& long_opt, const std::string& short_opt) {
         auto ptr = std::make_shared<SingleValueArgument<T, Converter>>(dest, long_opt, short_opt);
 
         //If the conversion object specifies a non-empty set of choices
@@ -18,7 +18,7 @@ namespace argparse {
     }
 
     template<typename T, typename Converter>
-    std::shared_ptr<Argument> make_multivalue_argument(ArgValue<T>& dest, std::string long_opt, std::string short_opt) {
+    std::shared_ptr<Argument> make_multivalue_argument(ArgValue<T>& dest, const std::string& long_opt, const std::string& short_opt) {
         auto ptr = std::make_shared<MultiValueArgument<T, Converter>>(dest, long_opt, short_opt);
 
         //If the conversion object specifies a non-empty set of choices
@@ -36,34 +36,34 @@ namespace argparse {
      */
 
     template<typename T, typename Converter>
-    Argument& ArgumentParser::add_argument(ArgValue<T>& dest, std::string option) {
+    Argument& ArgumentParser::add_argument(ArgValue<T>& dest, const std::string& option) {
         return add_argument<T,Converter>(dest, option, std::string());
     }
 
     template<typename T, typename Converter>
-    Argument& ArgumentParser::add_argument(ArgValue<T>& dest, std::string long_opt, std::string short_opt) {
+    Argument& ArgumentParser::add_argument(ArgValue<T>& dest, const std::string& long_opt, const std::string& short_opt) {
         return argument_groups_[0].add_argument<T,Converter>(dest, long_opt, short_opt);
     }
 
     template<typename T, typename Converter>
-    Argument& ArgumentParser::add_argument(ArgValue<std::vector<T>>& dest, std::string option) {
+    Argument& ArgumentParser::add_argument(ArgValue<std::vector<T>>& dest, const std::string& option) {
         return add_argument<T,Converter>(dest, option, std::string());
     }
 
     template<typename T, typename Converter>
-    Argument& ArgumentParser::add_argument(ArgValue<std::vector<T>>& dest, std::string long_opt, std::string short_opt) {
+    Argument& ArgumentParser::add_argument(ArgValue<std::vector<T>>& dest, const std::string& long_opt, const std::string& short_opt) {
         return argument_groups_[0].add_argument<T,Converter>(dest, long_opt, short_opt);
     }
     /*
      * ArgumentGroup
      */
     template<typename T, typename Converter>
-    Argument& ArgumentGroup::add_argument(ArgValue<T>& dest, std::string option) {
+    Argument& ArgumentGroup::add_argument(ArgValue<T>& dest, const std::string& option) {
         return add_argument<T,Converter>(dest, option, std::string());
     }
 
     template<typename T, typename Converter>
-    Argument& ArgumentGroup::add_argument(ArgValue<T>& dest, std::string long_opt, std::string short_opt) {
+    Argument& ArgumentGroup::add_argument(ArgValue<T>& dest, const std::string& long_opt, const std::string& short_opt) {
         arguments_.push_back(make_singlevalue_argument<T,Converter>(dest, long_opt, short_opt));
 
         auto& arg = arguments_[arguments_.size() - 1];
@@ -72,12 +72,12 @@ namespace argparse {
     }
 
     template<typename T, typename Converter>
-    Argument& ArgumentGroup::add_argument(ArgValue<std::vector<T>>& dest, std::string option) {
+    Argument& ArgumentGroup::add_argument(ArgValue<std::vector<T>>& dest, const std::string& option) {
         return add_argument<T,Converter>(dest, option, std::string());
     }
 
     template<typename T, typename Converter>
-    Argument& ArgumentGroup::add_argument(ArgValue<std::vector<T>>& dest, std::string long_opt, std::string short_opt) {
+    Argument& ArgumentGroup::add_argument(ArgValue<std::vector<T>>& dest, const std::string& long_opt, const std::string& short_opt) {
         arguments_.push_back(make_multivalue_argument<std::vector<T>,Converter>(dest, long_opt, short_opt));
 
         auto& arg = arguments_[arguments_.size() - 1];
diff --git a/src/argparse_default_converter.hpp b/src/argparse_default_converter.hpp
index 372a13e..26afcab 100644
--- a/src/argparse_default_converter.hpp
+++ b/src/argparse_default_converter.hpp
@@ -38,7 +38,7 @@ arg_type() { return ""; } //Empty
 template<typename T>
 class DefaultConverter {
     public:
-        ConvertedValue<T> from_str(std::string str) {
+        ConvertedValue<T> from_str(const std::string& str) {
             std::stringstream ss(str);
 
             T val = T();
@@ -90,13 +90,13 @@ class DefaultConverter {
 template<>
 class DefaultConverter<bool> {
     public:
-        ConvertedValue<bool> from_str(std::string str) {
+        ConvertedValue<bool> from_str(const std::string& str) {
             ConvertedValue<bool> converted_value;
 
-            str = tolower(str);
-            if (str == "0" || str == "false") {
+            std::string lower = tolower(str);
+            if (lower == "0" || lower == "false") {
                 converted_value.set_value(false); 
-            } else if (str == "1" || str == "true") {
+            } else if (lower == "1" || lower == "true") {
                 converted_value.set_value(true); 
             } else {
                 converted_value.set_error("Unexpected value '" + str + "' (expected one of: " + join(default_choices(), ", ") + ")");
@@ -122,12 +122,12 @@ class DefaultConverter<bool> {
 template<>
 class DefaultConverter<std::string> {
     public:
-        ConvertedValue<std::string> from_str(std::string str) { 
+        ConvertedValue<std::string> from_str(const std::string& str) { 
             ConvertedValue<std::string> converted_value;
             converted_value.set_value(str);
             return converted_value;
         }
-        ConvertedValue<std::string> to_str(std::string val) {
+        ConvertedValue<std::string> to_str(const std::string& val) {
             ConvertedValue<std::string> converted_value;
             converted_value.set_value(val);
             return converted_value;
@@ -140,7 +140,7 @@ class DefaultConverter<std::string> {
 template<>
 class DefaultConverter<const char*> {
     public:
-        ConvertedValue<const char*> from_str(std::string str) { 
+        ConvertedValue<const char*> from_str(const std::string& str) { 
             ConvertedValue<const char*> val;
             val.set_value(strdup(str.c_str()));
             return val;
@@ -158,7 +158,7 @@ class DefaultConverter<const char*> {
 template<>
 class DefaultConverter<char*> {
     public:
-        ConvertedValue<char*> from_str(std::string str) { 
+        ConvertedValue<char*> from_str(const std::string& str) { 
             ConvertedValue<char*> val;
             val.set_value(strdup(str.c_str()));
             return val;
diff --git a/src/argparse_util.cpp b/src/argparse_util.cpp
index 6dec30a..ddfc1cd 100644
--- a/src/argparse_util.cpp
+++ b/src/argparse_util.cpp
@@ -4,7 +4,7 @@
 
 namespace argparse {
 
-    std::array<std::string,2> split_leading_dashes(std::string str) {
+    std::array<std::string,2> split_leading_dashes(const std::string& str) {
         auto iter = str.begin();
         while(*iter == '-') {
             ++iter;
@@ -12,12 +12,12 @@ namespace argparse {
 
         std::string dashes(str.begin(), iter);
         std::string name(iter, str.end());
-        std::array<std::string,2> array = {dashes, name};
+        std::array<std::string,2> array = {std::move(dashes), std::move(name)};
 
         return array;
     }
 
-    bool is_argument(std::string str, const std::map<std::string,std::shared_ptr<Argument>>& arg_map) {
+    bool is_argument(const std::string& str, const std::map<std::string,std::shared_ptr<Argument>>& arg_map) {
 
         for (const auto& kv : arg_map) {
             auto iter = arg_map.find(str);
@@ -39,7 +39,7 @@ namespace argparse {
         return false;
     }
 
-    bool is_valid_choice(std::string str, const std::vector<std::string>& choices) {
+    bool is_valid_choice(const std::string& str, const std::vector<std::string>& choices) {
         if (choices.empty()) return true;
 
         auto find_iter = std::find(choices.begin(), choices.end(), str);
@@ -49,7 +49,7 @@ namespace argparse {
         return true;
     }
 
-    std::string toupper(std::string str) {
+    std::string toupper(const std::string& str) {
         std::string upper;
         for (size_t i = 0; i < str.size(); ++i) {
             char C = ::toupper(str[i]);
@@ -58,7 +58,7 @@ namespace argparse {
         return upper;
     }
 
-    std::string tolower(std::string str) {
+    std::string tolower(const std::string& str) {
         std::string lower;
         for (size_t i = 0; i < str.size(); ++i) {
             char C = ::tolower(str[i]);
@@ -74,7 +74,7 @@ namespace argparse {
         return res;
     }
 
-    std::vector<std::string> wrap_width(std::string str, size_t width, std::vector<std::string> break_strs) {
+    std::vector<std::string> wrap_width(const std::string& str, size_t width, const std::vector<std::string>& break_strs) {
         std::vector<std::string> wrapped_lines;
 
         size_t start = 0;
@@ -114,7 +114,7 @@ namespace argparse {
         return wrapped_lines;
     }
 
-    std::string basename(std::string filepath) {
+    std::string basename(const std::string& filepath) {
 #ifdef _WIN32
         //Windows uses back-slash as directory divider
         auto pos = filepath.rfind('\\');
diff --git a/src/argparse_util.hpp b/src/argparse_util.hpp
index dbd5802..d76a1aa 100644
--- a/src/argparse_util.hpp
+++ b/src/argparse_util.hpp
@@ -11,34 +11,34 @@ namespace argparse {
 
     //Splits off the leading dashes of a string, returning the dashes (index 0)
     //and the rest of the string (index 1)
-    std::array<std::string,2> split_leading_dashes(std::string str);
+    std::array<std::string,2> split_leading_dashes(const std::string& str);
 
     //Converts a string to upper case
-    std::string toupper(std::string str);
+    std::string toupper(const std::string& str);
 
     //Converts a string to lower case
-    std::string tolower(std::string str);
+    std::string tolower(const std::string& str);
 
     //Returns true if str represents a named argument starting with
     //'-' or '--' followed by one or more letters
-    bool is_argument(std::string str, const std::map<std::string,std::shared_ptr<Argument>>& arg_map);
+    bool is_argument(const std::string& str, const std::map<std::string,std::shared_ptr<Argument>>& arg_map);
 
     //Returns true if str is in choices, or choices is empty
-    bool is_valid_choice(std::string str, const std::vector<std::string>& choices);
+    bool is_valid_choice(const std::string& str, const std::vector<std::string>& choices);
 
     //Returns 'str' interpreted as type T
     // Throws an exception if conversion fails
     template<typename T> 
-    T as(std::string str);
+    T as(const std::string& str);
 
     template<typename Container>
-    std::string join(Container container, std::string join_str);
+    std::string join(const Container& container, const std::string& join_str);
 
     char* strdup(const char* str);
 
-    std::vector<std::string> wrap_width(std::string str, size_t width, std::vector<std::string> split_str={" ", "/"});
+    std::vector<std::string> wrap_width(const std::string& str, size_t width, const std::vector<std::string>& split_str={" ", "/"});
 
-    std::string basename(std::string filepath);
+    std::string basename(const std::string& filepath);
 } //namespace
 
 #include "argparse_util.tpp"
diff --git a/src/argparse_util.tpp b/src/argparse_util.tpp
index efdfef5..d342969 100644
--- a/src/argparse_util.tpp
+++ b/src/argparse_util.tpp
@@ -4,7 +4,7 @@
 namespace argparse {
 
     template<typename T> 
-    T as(std::string str) {
+    T as(const std::string& str) {
         
         std::stringstream ss(str);
 
@@ -19,7 +19,7 @@ namespace argparse {
     }
 
     template<typename Container>
-    std::string join(Container container, std::string join_str) {
+    std::string join(const Container& container, const std::string& join_str) {
         std::stringstream ss;
 
         bool first = true;
diff --git a/src/argparse_value.hpp b/src/argparse_value.hpp
index 0afb2f7..68f164e 100644
--- a/src/argparse_value.hpp
+++ b/src/argparse_value.hpp
@@ -11,7 +11,7 @@ namespace argparse {
             typedef T value_type;
         public:
             void set_value(T val) { errored_ = false; value_ = val; }
-            void set_error(std::string msg) { errored_ = true; error_msg_ = msg; }
+            void set_error(const std::string& msg) { errored_ = true; error_msg_ = msg; }
 
             T value() const { return value_; }
             std::string error() const { return error_msg_; }
@@ -81,11 +81,11 @@ namespace argparse {
                 return value_;
             }
 
-            void set_argument_group(std::string grp) {
+            void set_argument_group(const std::string& grp) {
                 argument_group_ = grp;
             }
 
-            void set_argument_name(std::string name_str) {
+            void set_argument_name(const std::string& name_str) {
                 argument_name_ = name_str;
             }
         private: