main.cpp

[詳解]

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   main.cpp                                           :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: kamitsui <kamitsui@student.42tokyo.jp>     +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2025/05/20 16:29:42 by kamitsui          #+#    #+#             */
/*   Updated: 2025/06/03 20:52:59 by kamitsui         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */
 
#include "Animal.hpp"
#include "Brain.hpp"
#include "Cat.hpp"
#include "Dog.hpp"
#include "ScopedPointer.hpp"
#include "WrongAnimal.hpp"
#include "WrongCat.hpp"
#include <cstdlib>
#include <iostream>
#include <new>
 
static int arrayAnimals(void);
static void deepCopyTests(void);
static void stackTests(void);
 
int main() {
    const Animal *j = new Dog();
    const Animal *i = new Cat();
 
    delete j; // should not create a leak
    delete i;
 
    arrayAnimals();
    deepCopyTests();
    stackTests();
 
    return 0;
}
 
static int arrayAnimals(void) {
    std::cout << "\n--- Array of Animals ---" << std::endl;
    // ScopedPointer の配列を使用する
    // std::vector<ScopedPointer<Animal> > animals(10); // C++98でstd::vectorとScopedPointerを組み合わせるなら
    // 配列の要素数が多い場合はヒープに確保
    // ScopedPointer<Animal>* animals = 0; // C++98 nullptr
    ScopedPointer<Animal> animals[10]; // スタック上の固定サイズ配列
 
    try {
        // --- 割り当て失敗のシミュレーション設定 (テスト用) ---
        // g_alloc_counter = 0; // コメントアウト、グローバルに影響するため注意
        // g_fail_at_alloc_count = -1; // コメントアウト、グローバルに影響するため注意
 
        for (int k = 0; k < 10; ++k) {
            if (k < 5) {
                animals[k].reset(new Dog());
            } else {
                animals[k].reset(new Cat());
            }
            // ここで new が失敗すると std::bad_alloc がスローされ、
            // それまでに成功した animals[0]...animals[k-1] のデストラクタが自動的に呼ばれる。
        }
 
        std::cout << "\n--- Making Sounds in Animal Array ---" << std::endl;
        for (int k = 0; k < 10; ++k) {
            // 防御的な null チェック (new が失敗した場合に備える)
            if (animals[k].get()) {
                std::cout << "Animal [" << k << "] (type: " << animals[k]->getType() << ") says: " << std::endl;
                animals[k]->makeSound();
            } else {
                std::cerr << "Array element " << k << " is null, skipping sound." << std::endl;
            }
        }
 
        // 明示的な delete は不要。スコープを抜ける際に自動的に解放される。
        // for (int k = 0; k < 10; ++k) {
        //     delete animals[k];
        // }
 
    } catch (const std::bad_alloc &e) {
        std::cerr << "Memory allocation failed in arrayAnimals! " << e.what() << std::endl;
        // 例外捕捉後、既に割り当てた ScopedPointer のデストラクタが自動で呼ばれる。
        return EXIT_FAILURE; // エラーとして終了
    } catch (const std::exception &e) {
        std::cerr << "An unexpected standard error occurred in arrayAnimals: " << e.what() << std::endl;
        return EXIT_FAILURE;
    } catch (...) {
        std::cerr << "An unknown error occurred in arrayAnimals." << std::endl;
        return EXIT_FAILURE;
    }
 
    // 関数終了時に animals 配列の ScopedPointer オブジェクトがスコープを抜ける。
    // その際にそれぞれのデストラクタが呼ばれ、内部の Animal オブジェクトが解放される。
    std::cout << "\n--- Array of Animals finished ---" << std::endl;
    return 0;
}
 
static void deepCopyTests(void) {
    std::cout << "\n--- Deep Copy Tests ---" << std::endl;
 
    // Copy Constructor Test
    Dog originalDog;
    originalDog.getBrain()->setIdea(0, "Bone!");
    Dog copiedDog = originalDog; // Using copy constructor
 
    std::cout << "Original Dog's first idea: " << originalDog.getBrain()->getIdea(0) << std::endl;
    std::cout << "Copied Dog's first idea: " << copiedDog.getBrain()->getIdea(0) << std::endl;
 
    copiedDog.getBrain()->setIdea(0, "Squirrel!");
    std::cout << "Original Dog's first idea after copied Dog changed: " << originalDog.getBrain()->getIdea(0)
              << std::endl;
    std::cout << "Copied Dog's first idea after copied Dog changed: " << copiedDog.getBrain()->getIdea(0) << std::endl;
 
    // Copy Assignment Operator Test
    Cat originalCat;
    originalCat.getBrain()->setIdea(0, "Fish!");
    Cat assignedCat;
    assignedCat = originalCat; // Using copy assignment operator
 
    std::cout << "Original Cat's first idea: " << originalCat.getBrain()->getIdea(0) << std::endl;
    std::cout << "Assigned Cat's first idea: " << assignedCat.getBrain()->getIdea(0) << std::endl;
 
    assignedCat.getBrain()->setIdea(0, "Nap!");
    std::cout << "Original Cat's first idea after assigned Cat changed: " << originalCat.getBrain()->getIdea(0)
              << std::endl;
    std::cout << "Assigned Cat's first idea after assigned Cat changed: " << assignedCat.getBrain()->getIdea(0)
              << std::endl;
}
 
static void stackTests(void) {
    std::cout << "\n--- More Tests (Stack Objects) ---" << std::endl;
    {
        Dog stackDog;
        stackDog.getBrain()->setIdea(50, "Walkies?");
        std::cout << "Stack Dog's 50th idea: " << stackDog.getBrain()->getIdea(50) << std::endl;
    } // stackDog and its Brain are destroyed here
    {
        Cat stackCat;
        stackCat.getBrain()->setIdea(99, "Laser pointer!");
        std::cout << "Stack Cat's 99th idea: " << stackCat.getBrain()->getIdea(99) << std::endl;
    } // stackCat and its Brain are destroyed here
}