实例化对象时如何修复分段故障错误

我正在努力创建一些类，以模拟租赁汽车代理的功能。我的类工作可以创建每个类的对象，但是当我尝试运行以下代码时，我会收到一个分段故障，我不确定为什么。当我按照此顺序声明对象时，为什么会遇到细分错误？

我已经尝试切换我声明对象的顺序，并且错误消失了。如果我仅使用Car()构造函数声明两辆汽车，那么问题也消失了。如果我删除了汽车或传感器类中的任何功能，则错误会消失。

ps：几天前我问了这个问题，我包括了太多的代码，因为我无法识别错误（远非完整，最小和可验证），但是这次我将其缩小为尽我所能。如果有很多代码，我深表歉意，但是我删除了所有我可以的代码，如果我删除了其他代码，则问题消失了。

这是我的主要文件：

#include "Car.h"
int main() {
    char make[] = "Subaru", model[] = "Outback", name[] = "Brandon", 
type[] = "radar";
    Sensor sensors[3];
    Sensor sensor1 = Sensor(type), sensor2 = Sensor(), sensor3 = 
           Sensor();
    sensors[0] = sensor1;
    sensors[1] = sensor2;
    sensors[2]= sensor3;
    Car car1 = Car();
    Car car2 = Car(make, 155.81, sensors);
    return 0;
}

我的汽车课：

#ifndef CAR_H
#define CAR_H
#include <iostream>
#include "MyString.h"
#include "Sensor.h"
using namespace std;
#define MAX_STR_SIZE 256
#define MAX_NUM_SNSRS 3
class Car {
    public:
     Car();
     Car(char* make, float baseprice, Sensor* sensors);
     void setMake(char* make);
     void setBaseprice(float baseprice);
     void setAvailable(bool available);
     void setOwner(char* owner);
     void updatePrice();
    private:
     char m_make[MAX_STR_SIZE];
     Sensor m_sensors[MAX_NUM_SNSRS];
     int m_numsensors;
     float m_baseprice;
     float m_finalprice;
     bool m_available;
     char m_owner[MAX_STR_SIZE];
};
#endif
#include "Car.h"
Car::Car() {
    char dflt[] = {''};
    setMake(dflt);
    setAvailable(true);
    setOwner(dflt);
    m_numsensors = 0;
    setBaseprice(0.0);
}
Car::Car(char* make, float baseprice, Sensor* sensors) {
    char dflt[] = {''};
    setMake(make);
    setAvailable(true);
    setOwner(dflt);
    for(int i = 0; i < MAX_NUM_SNSRS; i++) {
        (*(m_sensors + i)) = Sensor(*(sensors + i));
        if(myStringCompare((sensors + i)->getType(), "none") != 0) {
            m_numsensors++;
        }
    }
    setBaseprice(baseprice);
}
void Car::setMake(char* make) {
    myStringCopy(m_make, make);
}
void Car::setBaseprice(float baseprice) {
    m_baseprice = baseprice;
    updatePrice();
}
void Car::setAvailable(bool available) {
    m_available = available;
}
void Car::setOwner(char* owner) {
    myStringCopy(m_owner, owner);
}
void Car::updatePrice() {
    float totSnsrPrice = 0.0;
    for(int i = 0; i < m_numsensors; i++) {
        totSnsrPrice += (m_sensors + i)->getCost();
    }
    m_finalprice = m_baseprice + totSnsrPrice;
}

我的传感器类：

#ifndef SENSOR_H
#define SENSOR_H
#include "MyString.h"
#define MAX_STR_SIZE 256
#define NUM_TYPES 5
class Sensor {
    public:
     Sensor();
     Sensor(char* type);
     char* getType();
     float getCost();
     void setType(char* type);
     void setCost(float extraCost);
    private:
     char m_type[MAX_STR_SIZE];
     float m_extracost;
};
#endif
#include "Sensor.h"
const char* validSensors[] = {"gps", "camera", "lidar", "radar", 
                              "none"};
const float prices[] = {5.0, 10.0, 15.0, 20.0, 0.0};
Sensor::Sensor() {
    char dflt[] = "none";
    setType(dflt);
    setCost(0.0);
}
Sensor::Sensor(char* type) {
    int index = -1;
    char dflt[] = "none";
    for(int i = 0; i < NUM_TYPES; i++) {
        if(myStringCompare(type, *(validSensors + i)) == 0) {
            index = i;
        }
    }
    if(index < 0) {
        setType(dflt);
        setCost(0.0);
    } else {
        setType(type);
        setCost(*(prices + index));
    }
}
char* Sensor::getType() {
    return m_type;
}
float Sensor::getCost() {
    return m_extracost;
}
void Sensor::setType(char* type) {
    myStringCopy(m_type, type);
}
void Sensor::setCost(float extracost) {
    m_extracost = extracost;
}

mystringcopy和mystringCompare只是典型的std ::字符串复制和比较函数，我们只是不允许使用它们（它们包括在mystring.h中。h，我已经使用了一段时间了，所以我知道他们按预期工作）。

我希望输出一无所有，但仍然成功，而不是细分故障。我在任何地方都找不到错误，任何帮助将不胜感激。谢谢！

编辑：这是我的字符串类，如：

#ifndef MYSTRING_H
#define MYSTRING_H
int myStringCompare(const char* str1, const char* str2);
char* myStringCopy(char* destination, const char* source);
#endif
#include "MyString.h"
int myStringCompare(const char* str1, const char* str2) {
    int index = 0;
    while(*(str1 + index) != '' || *(str2 + index) != '') {
        if(*(str1 + index) < *(str2 + index)) {
            return -1;
        }
        if(*(str1 + index) > *(str2 + index)) {
            return 1;
        }
        index++;
    }
    return 0;
}
char* myStringCopy(char* destination, const char* source) {
    int index = 0;
    while(*(source + index) != '') {
        *(destination + index) = *(source + index);
        index++;
    }
    *(destination + index) = '';
    return destination;
}