添加异常后的奇怪行为

Question

I added some exception handling into some functions in my Project. Before adding the error handling the program was working normally. After adding the exceptions I now get garbage values in the constructor and mutator parameters and I'm not sure where its coming from. Some of the functions are called in no other location than the constructor, so I have no idea where they are getting the garbage data from.

I also checked for memory leaks with valgrind and some debugging with gdb, but didn't find anything. I'm at my wits end. I have attached a sample of the constructor cpp below and one of the mutators with the exception handling.

Protofield.cpp

ProtoField::ProtoField(std::string t_name, std::string t_abbreviation, FieldType t_type, Base t_base, int t_mask, std::string t_description, int t_offset, int t_length){
    try{
        setName(t_name);
        setAbbreviation(t_abbreviation);
        setType(t_type);
        setBase(t_base);
        setMask(t_mask);
        setDescription(t_description);
        setOffset(t_offset);
        setLength(t_length);
        m_valueString = std::map<int, std::string>();
    }
    catch(std::runtime_error e){
        std::cerr<<"Error in ProtoField Constructor"<<std::endl;
        std::cerr<<e.what()<<std::endl;
        return;
    }
}
/*Removed for brevity*/
void ProtoField::setMask(int t_mask){
    if(mask != 0){
        std::stringstream ss;
        ss<<"Field " << m_abbreviation << " mask previously set: "<<m_mask;
        throw std::runtime_error(ss.str());
    }
    else{
        m_mask = t_mask;
    }
    return;
}
/*Removed for brevity*/

ProtoField.hpp

class ProtoField{
    private:
        std::string m_name;
        std::string m_abbreviation;
        FieldType m_type;
        Base m_base;
        int m_mask;
        std::string m_description;
        int m_offset;
        int m_length;
        std::map<int, std::string> m_valueString;
    public:
        ProtoField(
            std::string t_name = "",
            std::string t_abbreviation = "",
            FieldType t_type = FieldType::ft_invalid,
            Base t_base = Base::invalid,
            int t_mask = 0,
            std::string t_description = "", 
            int t_offset = -1,
            int t_length = -1
        );

        std::string getName();
        std::string getAbbreviation();
        FieldType getType();
        Base getBase();
        int getMask();
        std::string getDescription();
        int getOffset();
        int getLength();
        std::map<int, std::string> getValueString();

        void setName(std::string t_name);
        void setAbbreviation(std::string t_abbreviation);
        void setType(FieldType t_type);
        void setType(std::string t_typestr);
        void setBase(Base t_base);
        void setBase(std::string t_basestr);
        void setMask(int t_mask);
        void setDescription(std::string t_description);
        void setOffset(int t_offset);
        void setLength(int t_length);
        void addValueString(int t_key, std::string t_value);
        void removeValueString(int t_key);

        //other functions
        std::string to_string();
    };

I feel as though its also worth mentioning, only integers appear to be affected. The other values including strings and enums seem to remain consistent with their previous behaviors. So in the class shown, only the mask, offset, and length show odd behaviors.

Edit: For more detail where the constructor is called I included the two functions I know of here.

void parser::parseFields(ProtoData& t_data, ptree::ptree t_subtree){
        try{
            std::vector<ProtoField> fields;
            for(auto val : t_subtree.get_child("")){
                ProtoField field;
                parseField(t_data, field, val.second);
                fields.push_back(field);
            }
            for(auto field:fields){
                t_data.addField(field);
            }
        }
        catch(ptree::ptree_bad_path error){
            std::cerr<<"Bad Path to Fields"<<std::endl;
        }
        catch(ptree::ptree_bad_data error){
            std::cerr<<"Bad Data to fields"<<std::endl;
        }
    }

    void parser::parseField(ProtoData& t_data, ProtoField& t_field, ptree::ptree t_subtree){
        try{
            t_field.setAbbreviation(t_subtree.get<std::string>("abbreviation"));
            t_field.setName(t_data.getName() + "_" + t_field.getAbbreviation());
            t_field.setBase(t_subtree.get<std::string>("base", "none"));
            t_field.setType(t_subtree.get<std::string>("type"));
        }
        catch(ptree::ptree_bad_path error){
            std::cerr<<"Bad Path to Field"<<std::endl;
        }
        catch(ptree::ptree_bad_data error){
            std::cerr<<"Bad Data to field"<<std::endl;
        }
    }

Answer 1

Your constructor does not initialize m_mask . You then call setMask , which reads this yet-to-be-initialzed value (assuming that the if(mask != 0) line should be if(m_mask != 0) ). This is Undefined Behavior. The value read could be anything. When it is a nonzero value, the exception will be thrown.

The solution is to either initialize m_mask before calling setMask , or assign to m_mask directly in the constructor and not call the helper function. (And since the constructor sets the mask, which can only be done once, why does that function even need to exist?)