[React] Can't resolve 'queryString' in ...

벼리01 — Thu, 13 Mar 2025 14:25:19 +0900

갑자기 이 오류가 뜨면서 웹 애플리케이션이 실행되지 않음

import {enabled} from "express/lib/application";

객체 내 `enabled`를 사용하기 위해 코드를 작성하던 도중 import 문이 잘못 작성되면서 생긴 오류.

[React] 리덕스(Redux)

벼리01 — Tue, 4 Mar 2025 10:48:45 +0900

리덕스(Redux)

리액트에서 사용되는 상태 관리 라이브러리. 주요 개념은 다음과 같다.

읽기 전용 상태 리덕스에서 전역으로 관리하는 값은 읽기 전용으로, 직접 변경할 수 없다.

단일 스토어 전체 애플리케이션에서 접근 가능한 상태들을 저장하고 있는 하나의 객체.

액션 상태의 변경을 요청하기 위한 객체.

리듀서 액션과 이전 상태를 받아 새로운 상태를 반환하는 순수 함수.

흐름

컴포넌트 - 액션 생성 - 디스패치 - 스토어 - 리듀서 - 새 상태 - 컴포넌트 리렌더링

상태(State)

전체 애플리케이션 어디서든 접근하고 공통으로 사용할 수 있도록 선언된 전역변수와 유사하다. 단, 리덕스는 단방향 데이터 흐름을 가지므로 읽기는 어디서든 자유롭게 가능하지만 수정은 반드시 액션을 통해서만 이루어진다.

스토어(Store)

상태를 보관하는 중앙 관리자 객체. 액션이 스토어에게 "이런 변경이 필요해" 라는 정보와 변경에 필요한 값을 들고오면 그 요청을 처리할 수 있는 리듀서를 찾아 처리를 위임한다. 액션은 리듀서에게 직접 상태 변경을 요청할 수 없고, 스토어라는 중앙 관리자를 통해 간접적으로 상호작용한다.

// store.js

import { createStore, combineReducers } from 'redux';
import userReducer from './reducers/userReducer';
import todoReducer from './reducers/todoReducer';

// 여러 리듀서 결합
const rootReducer = combineReducers({
  user: userReducer,
  todos: todoReducer
});


const store = createStore(
  rootReducer,
);

export default store;

액션(Action)

상태 변경을 요청하기 위해 필요한 객체. 반드시 타입(type)이라는 프로퍼티를 포함하는데, 이는 고유 식별자라고 할 수 있다. '무엇을 해야하는지' 에 대한 정보를 담고 있으며 이를 `dispatch()` 함수를 통해 스토어에게 전달한다. 타입을 문자열 상수로 저장하기 위해 `contants` 객체를 따로 관리하기도 한다.

예)

증가 시켜줘! 라는 뜻을 담은 `type` 과

상태 변화에 필요한 값인 `payload` 에 1을 담아 들고 온다.

스토어에게 "1을 증가시켜줘" 상태 변경을 요청하면 스토어가 해당 액션을 처리할 수 있는 리듀서를 찾아 실행시킨다.

export const increment = (value) => ({
  type: 'INCREMENT',	// Action의 고유 식별자
  payload: value,	// 상태 업데이트에 필요한 추가 데이터 (선택 사항)
});

리듀서(Reducer)

타입과 값을 받아 상태 변경을 처리한다. 액션이 `INCREMENT` 타입과 `1`을 가져왔다면 실제로 상태를 1 증가시키는 로직을 처리한다.

// Reducer

// 초기 상태 정의
const initialState = {
  count: 0
};

const counterReducer = (state = initialState, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return {
        ...state, // 기존 상태 복사
        count: state.count + action.payload
      };
    default:
      return state;
  }
};

export default counterReducer;

다음과 같이 사용할 수 있다.

dispatch({ type: 'INCREMENT', payload: 1 });

예제

// todoAction.js

// 액션 타입 상수(constant.js로 따로 분리할 수 있음)
export const ADD_TODO = 'ADD_TODO';
export const TOGGLE_TODO = 'TOGGLE_TODO';
export const DELETE_TODO = 'DELETE_TODO';


export const addTodo = (text) => ({
  type: ADD_TODO,
  payload: {
    id: Date.now(),
    text,
    completed: false
  }
});

export const toggleTodo = (id) => ({
  type: TOGGLE_TODO,
  payload: id
});

export const deleteTodo = (id) => ({
  type: DELETE_TODO,
  payload: id
});

// todoReducers.js

import { ADD_TODO, TOGGLE_TODO, DELETE_TODO } from './todoActions';

// 초기 상태
const initialState = [];

// 할일 리듀서
const todoReducer = (state = initialState, action) => {
  switch (action.type) {
    case ADD_TODO:
      // 새 할일 항목 추가
      return [...state, action.payload];
    
    case TOGGLE_TODO:
      // 특정 할일의 완료 상태 토글
      return state.map(todo => 
        todo.id === action.payload 
          ? { ...todo, completed: !todo.completed } 
          : todo
      );
    
    case DELETE_TODO:
      // 특정 할일 삭제
      return state.filter(todo => todo.id !== action.payload);
    
    default:
      return state;
  }
};

export default todoReducer;

// store.js

import { createStore, combineReducers } from 'redux';
import todoReducer from './todoReducers';

// 루트 리듀서 (여러 리듀서를 결합할 수 있음)
const rootReducer = combineReducers({
  todos: todoReducer,
  // 다른 리듀서들도 여기에 추가 가능
  // user: userReducer,
  // posts: postsReducer
});

// 스토어 생성
const store = createStore(
  rootReducer,
  // Redux DevTools 확장 프로그램 연결 (선택 사항)
  window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__()
);

export default store;

// App.js - 리액트 앱에 리덕스 스토어 연결

import React from 'react';
import { Provider } from 'react-redux';
import store from './store';
import TodoComponent from './TodoComponent';

function App() {
  return (
    <Provider store={store}>
      <div className="App">
        <h1>할일 관리 앱</h1>
        <TodoComponent />
      </div>
    </Provider>
  );
}

export default App;

// TodoComponent.js 컴포넌트

import React, { useState } from 'react';
import { useSelector, useDispatch } from 'react-redux';
import { addTodo, toggleTodo, deleteTodo } from './actions';

function TodoComponent() {
  const [todoText, setTodoText] = useState('');
  const todos = useSelector(state => state.todos);
  const dispatch = useDispatch();
  
  const handleAddTodo = () => {
    if (todoText.trim()) {
      dispatch(addTodo(todoText));
      setTodoText('');
    }
  };
  
  const handleToggleTodo = (id) => {
    dispatch(toggleTodo(id));
  };
  
  const handleDeleteTodo = (id) => {
    dispatch(deleteTodo(id));
  };
  
  return (
    <div>
      <div>
        <input
          type="text"
          value={todoText}
          onChange={(e) => setTodoText(e.target.value)}
          placeholder="할일을 입력하세요"
        />
        <button onClick={handleAddTodo}>할일 추가</button>
      </div>
      
      <ul>
        {todos.map(todo => (
          <li key={todo.id}>
            <span
              style={{ textDecoration: todo.completed ? 'line-through' : 'none' }}
              onClick={() => handleToggleTodo(todo.id)}
            >
              {todo.text}
            </span>
            <button onClick={() => handleDeleteTodo(todo.id)}>삭제</button>
          </li>
        ))}
      </ul>
    </div>
  );
}

export default TodoComponent;

참고

리덕스는 무엇이고, 왜 사용하는가?

리덕스 리덕스란, 자바스크립트 애플리케이션에서 상태를 효율적으로 관리할 수 있게 도와주는 도구입니다. 복잡한 상태관리가 이루어지는 SPA(Single Page Application)에서 특히 유용하게 사용됩

velog.io

[HTML/CSS] 자주 쓰는 태그/스타일

벼리01 — Thu, 17 Oct 2024 10:21:18 +0900

말줄임

.review {
  overflow: hidden;
  white-space: nowrap;
  text-overflow: ellipsis;
  word-break: break-all;
}

p {
	text-align: center;
    width: 100%;
    overflow: hidden;
    word-wrap: break-word;
}

`overflow: hidden;` 박스에서 넘쳐난 텍스트 숨기기
`white-space: nowrap;` 줄바꿈이 없어짐
`text-overflow: ellipsis;` ... 말줄임 효과
`word-break: break-all;` 어절이 유지되지 않고 끊어져서 줄바꿈 됨

`word-wrap : break-word;` width를 초과하면 줄바꿈

배경 블러(반투명)

.goTop{
	backdrop-filter: blur(50px);
}

input 박스 테두리 없애기

input {
        outline: none;
}

기호 태그

` ` 띄어쓰기

`©` copyright

`<` < less than

`>` > greater than

`&` & 앰퍼센트

`#` #

`'` ' 작은따옴표

참고

️ ＆nbsp /＆amp /＆lt /＆gt /＆quot 기호 의미

＆nbsp /＆amp /＆lt /＆gt /＆quot 가끔 HTML문서에 텍스트를 작성하고 웹으로 확인하면 꺽쇠 < > 로 둘러싸인 부분은 표기가 되지 않는 경우가 있다. 그 책의 제목은 이다. 와 같이 입력하면, 아래와 같

inpa.tistory.com

[JavaScript] 문자열 비교

벼리01 — Mon, 7 Oct 2024 11:23:17 +0900

문자열 상수 풀(string constant pool)

자바가 문자열을 string pool에서 관리하듯이 자바스크립트는 string constant pool에서 문자열 메모리를 관리한다. 만약 이미 메모리에 할당된 문자열이 있다면, 새 변수에 해당 문자열을 할당하더라도 메모리를 새로 생성하지 않고 주소값을 반환한다.

How are strings stored in JavaScript ? - GeeksforGeeks

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

www.geeksforgeeks.org

문자열 비교 연산

let str1 = "Hello";
let str2 = "Hello";

console.log(`str1 === str3 : ${str1 === str2}`);

// str1 === str3 : true

let str1 = "Hello";
let str2 = new String("Hello");

console.log(`str1 == str3 : ${str1 == str2}`);
console.log(`str1 === str3 : ${str1 === str2}`);

// str1 == str3 : true
// str1 === str3 : false

`===` 는 주소값과 자료형까지 검사한다. `str2` 를 `new` 연산자 없이 사용했을 경우 같은 문자열 리터럴의 주소를 참조하기 때문에 참이 되지만, `new String()` 생성자를 사용해 객체를 생성하면 다른 주소값을 가진 문자열 리터럴이 된다.

console.log(`2024 == '2024' : ${2024 == "2024"}`);
console.log(`2024 === '2024' : ${2024 === "2024"}`);

// 2024 == '2024' : true
// 2024 === '2024' : false

`localeCompare()`

문자열 비교 시 정렬 순서를 결정하는 데에 사용한다.

`-1` `a`가 `b`보다 사전순으로 앞에 위치함

`0` `a`와 `b`가 같음

`1` `a`가 `b`보다 사전순으로 뒤에 위치함

프로그래머스의 [Lv.1][문자열 내 마음대로 정렬하기] 문제에서, 주어진 문자열 배열을 문자열의 사전순이 아닌 두번째 알파벳 순서대로 정렬하고자 할 때(단, 동일하면 문자열 전체의 사전순으로 정렬한다.) 다음과 같이 코드를 작성할 수 있다.

function solution(strings, n) {
    return strings.sort( (a, b) => {

        if(a.charAt(n) < b.charAt(n)){
            return -1;
        }else if(a.charAt(n) > b.charAt(n)){
            return 1;
        }

        return a.localeCompare(b);

    });

}

[JavaScript] Kakao Map API

벼리01 — Thu, 19 Sep 2024 16:12:19 +0900

카카오맵 api 시작하기

Kakao Developers

카카오 API를 활용하여 다양한 어플리케이션을 개발해보세요. 카카오 로그인, 메시지 보내기, 친구 API, 인공지능 API 등을 제공합니다.

developers.kakao.com

지도 띄우기

Kakao Map API를 발급 받았다면 이제 지도를 사용할 수 있다. `html` 파일에 다음과 같은 스크립트를 추가한다.

 <script type="text/javascript" src="//dapi.kakao.com/v2/maps/sdk.js?appkey=YOUR_API_KEY&libraries=services"></script>

`html`에 `map`을 띄울 적당한 요소를 만든다.

 <div class="map"></div>

다음과 같이 js 코드를 작성하면 지도를 띄울 수 있다.

  const mapContainer = document.querySelector(".map"); // 지도를 표시할 div

  const mapOption = {
    center: new kakao.maps.LatLng(latitude, longitude), // 지도의 중심좌표 (위도, 경도)
    level: 6, // 지도의 확대 레벨. 클수록 멀리 보임
  };

  // 지도 생성
  const map = new kakao.maps.Map(mapContainer, mapOption);

쨘

[지도 생성하기]

https://apis.map.kakao.com/web/sample/basicMap/

지도에 마커 추가하기

const mapContainer = document.querySelector(".map"); // 지도를 표시할 div

const mapOption = {
center: new kakao.maps.LatLng(latitude, longitude), // 지도의 중심좌표 (위도, 경도)
level: 6, // 지도의 확대 레벨. 클수록 멀리 보임
};

// 지도 객체 생성
const map = new kakao.maps.Map(mapContainer, mapOption);
  
  
const marker = new kakao.maps.Marker({
  map: map,
  position: new kakao.maps.LatLng(latitude, longitude),
});

[마커 띄우기]

https://apis.map.kakao.com/web/sample/basicMarker/

커스텀 마커 만들기

  const mapContainer = document.querySelector(".map"); // 지도를 표시할 div

  const mapOption = {
    center: new kakao.maps.LatLng(latitude, longitude), // 지도의 중심좌표 (위도, 경도)
    level: 6, // 지도의 확대 레벨. 클수록 멀리 보임
  };

  // 지도 생성
  const map = new kakao.maps.Map(mapContainer, mapOption);


// 커스텀 마커 만들기
const customMarkerImage = new kakao.maps.MarkerImage(
  "images/marker-red.png", // 마커 이미지 URL
  new kakao.maps.Size(35, 35), // 마커 이미지 크기
  {
    offset: new kakao.maps.Point(17, 35), // 마커의 중심점 위치
  }
);


// 내 위치 마커 추가
new kakao.maps.Marker({
  position: new kakao.maps.LatLng(
    latitude,
    longitude
  ),
  map: map,
  clickable: true,
  image: customMarkerImage,
});

[커스텀 마커 만들기]

https://apis.map.kakao.com/web/sample/basicMarkerImage/

마커에 이벤트 추가하기

  kakao.maps.event.addListener(marker, "mouseover", function () {
      infowindow.open(map, marker);
      spot.style.outline = "solid 2px #96b9ff";
    });

    kakao.maps.event.addListener(marker, "click", () => {
      spot.style.backgroundColor = "#96b9ff";
      spot.style.outline = "";
      spot.style.color = "white";

      const spotDiv = document.querySelector(`[data-id="${place.id}"]`);
      if (spotDiv) {
        spotDiv.scrollIntoView({
          behavior: "smooth", // 스크롤 애니메이션 (부드럽게)
          block: "start", // 요소의 상단으로 스크롤 정렬
          inline: "nearest", // 수평 위치도 맞춤
        });
      }
    });

[마커 마우스 이벤트 추가하기]

https://apis.map.kakao.com/web/sample/addMarkerMouseEvent/

[마커 클릭 이벤트 추가하기]

https://apis.map.kakao.com/web/sample/addMarkerClickEvent/

지도 중심 변경하기

// 이동할 위도 경도 위치를 생성
var moveLatLon = new kakao.maps.LatLng(latitude, longitude);
// 지도 중심 이동
map.panTo(moveLatLon); // 부드럽게 이동. 단, 지도 내에 해당 위치가 없다면 일반 이동

키워드로 검색하기

  // 장소 검색 객체 생성
  const ps = new kakao.maps.services.Places();

  // 키워드 검색
  ps.keywordSearch(
    // keywordSearch(keyword, callback(data, status, pagination), locationInfo)
    "키워드",
    (data, status, pagination) => {
     // 여기에 검색 후 로직
    }, // callback 함수
    {
      location: new kakao.maps.LatLng(
        myLocation.latitude,
        myLocation.longitude
      ), // 중심 위치
      radius: 1000, // 반경 1km
      sort: "distance", // 거리순 정렬
    } // 중심이 될 위치 정보
  );

`radius` 찾고자 하는 중심 위치와 반경을 설정할 수 있다.

`sort` 거리순, 이름순, 관련도순으로 정렬할 수 있다.

`keywordSearch` 는 `data` `status` `pagination`을 반환한다. `data`에는 검색 결과 15개가 담겨있고, 결과가 15개 이상일 경우 `pagination` 을 통해 접근해야한다.

다음과 같은 조건문으로 상태가 올바를 때만 로직을 수행할 수 있다.

if (status === kakao.maps.services.Status.OK)

`data` 에는 검색 결과(1페이지)가 담겨있다.

`pagination` 은 검색 결과의 페이지 객체다.

`hasNextPage`는 다음 페이지의 존재 여부를 반환한다.

`nextPage()` 를 호출하면 다음 페이지를 볼 수 있으며 해당 메서드는 `keywordSearch`의 콜백함수를 자동으로 다시 호출한다.

[키워드로 장소 검색하기]

https://apis.map.kakao.com/web/sample/keywordBasic/

[C++] 스마트 포인터

벼리01 — Thu, 19 Sep 2024 09:54:19 +0900

포인터가 가리키는 메모리를 자동으로 해제하는 포인터. 개발자는 메모리 관리에 크게 신경 쓸 필요가 없다.

C++은 객체 생성 시 사용했던 동적 메모리 또는 시스템 자원을 소멸 시 자동으로 소멸시키는 매커니즘을 제공한다. 범위를 벗어난 변수는 스택에서 제거되며, 객체의 소멸자가 호출되어 자신이 사용하던 자원을 알아서 정리한다.

`auto_ptr` 동적으로 할당된 메모리도 자동으로 해제하는 래퍼 클래스. // deprecated. use unique_ptr instead.

`template<typename T> class auto_ptr`

포인터가 가리키는 대상의 타입 T 를 인자로 받아 `T*` 형 포인터를 관리한다. 생성자로 전달된 포인터는 소멸자에서 delete 로 해제한다.

  unique_ptr<double> rate(new double);
  *rate = 3.14;
  
  cout << *rate << endl;  // 3.14

함수가 종료되면 객체의 소멸자를 호출하기 때문에, `unique_ptr` 클래스 내 소멸자에 작성된 `delete` 가 포인터를 해제하면서 자동으로 해제되는 것처럼 보인다.

구현

#include <iostream>
#include <string>
#include <memory>

using namespace std;

template<typename T>
class my_smart_ptr {
    
    public:
    my_smart_ptr(T* ptr){
        this->my_ptr = ptr;
    }
    
    ~ my_smart_ptr(){
        delete this->my_ptr;
    }
    
    T* operator->() const{
        return my_ptr;
    }
    
    T operator*() const{
      return *my_ptr;  
    }
    
    
    private:
    T* my_ptr;
};

int main()
{
    my_smart_ptr<string> str(new string("test"));
  
    cout << *str << endl; // test  
    cout << str->size() << endl; // 4
  
    return 0;
}

`shared_ptr` (C++ 11 이후부터 표준 라이브러리에 포함되었음. C++ 11 이전에서 사용하려면 boost 라이브러리) 하나의 객체를 여러 포인터가 참조할 수 있도록 구현된 스마트 포인터 래퍼 클래스. 내부적으로 레퍼런스 카운팅을 수행하여 메모리를 가리키는 인스턴스의 수를 추적한다. 레퍼런스 카운터가 0이 되었을 때 메모리가 해제된다.

[C/C++ 프로그래밍 : 중급] 11. 스마트 포인터

Chapter 11. 스마트 포인터 스마트 포인터는 C++에서 동적 메모리 관리를 단순화하는 도구입니다. 그들은 기본 포인터와 비슷하게 동작하지만, 적절한 시점에 자동으로 메모리를 해제하여 메모리

gdngy.tistory.com

[C++] STL

벼리01 — Thu, 5 Sep 2024 14:44:40 +0900

STL(Standard Template Library)

표준 템플릿 라이브러리. 자료구조(컨테이너, 이터레이터, 알고리즘)를 모아놓은 라이브러리.

컨테이너(자료구조), 반복자(iterator), 알고리즘, 수치

기능을 제공하고 손쉽게 구현할 수 있도록 재사용을 목적으로 만들어진 라이브러리. C언어는 CRT(C Runtime Library)라는 이름의 라이브러리를, C++은 C++ Standard Library를 가지고 있다. 1994년 C++ 표준 라이브러리에 STL이 추가되었다.

표준 템플릿 라이브러리라는 뜻 그대로 일반화 프로그래밍(Generic Programming)을 기반으로 무분별한 여러가지 형태의 코드를 지양하고 표준화된 코드를 지향한다. 표준이므로 이식성이 좋다.

각 자료구조마다 성능의 차이가 있으므로 검색, 정렬, 삽입, 삭제에 최적화된 자료구조를 적절히 골라 사용한다.

예외 처리가 쉽지 않다는 단점이 있다.

컨테이너(Container)

Java의 컬렉션과 유사한 개념으로 데이터의 집합을 저장하고 관리하는데 사용한다.

시퀀스 컨테이너(순차 컨테이너) (Sequence Containers)
- vector 동적 배열로, 크기가 자동으로 조정된다. 인덱스를 통해 접근할 수 있으며, 효율적인 끝에 요소 추가/제거를 지원한다. 중간 삽입 삭제는 요소 개수에 따라 처리 속도가 비례한다. 모든 요소를 뒤로 밀거나 앞으로 당기기 때문. 유사) 동적배열, arraylist
- deque 양쪽 끝에서 빠르게 삽입/삭제가 가능한 데큐(더블 엔디드 큐). 성능 또한 벡터와 마찬가지로 요소 개수에 따라 처리 속도가 비례한다.
- list 양방향 연결 리스트로, 임의의 위치에서의 삽입과 삭제가 효율적. 요소의 삽입 및 삭제가 위치와 상관없이 같은 속도. 각각의 노드가 포인터로 연결되어있다.
- array 고정 크기의 배열. std::array는 크기가 컴파일 타임에 결정된다.
정렬 연관 컨테이너 (Sort Associative Containers)
- 연관된 다른 타입들을 담을 수 있는 컨테이너. 키를 사용하여 데이터를 신속하게 찾아낼 수 있음. 실행 시 크기를 동적으로 변경할 수 있음.
- set 고유한 요소들을 정렬된 상태로 저장한. 키의 중복은 허용하지 않는다. 원하는 키를 빠르게 찾아낸다.
- map 키-값 쌍을 저장하며, 키를 통해 값을 빠르게 조회할 수 있다. 키의 중복은 허용하지 않는다. 키를 사용하여 원하는 값, 즉 객체를 빠르게 찾아낸다. key:value
- multiset 중복을 허용하는 정렬된 집합.
- multimap 중복된 키를 허용하는 키-값 쌍의 집합.
비순차 컨테이너 (Unordered Containers)
- unordered_set 해시 기반의 집합으로, 요소들은 정렬되지 않음.
- unordered_map 해시 기반의 키-값 쌍의 집합.
- unordered_multiset 해시 기반의 중복을 허용하는 집합.
- unordered_multimap 해시 기반의 중복된 키를 허용하는 키-값 쌍의 집합.
반복자(Iterator)
- 컨테이너(또는 배열)의 요소를 순차적으로 읽기 위해서는 요소의 타입이 무엇인지 알아야한다. 요소의 메모리 크기만큼을 이동하며 읽어야 올바른 데이터를 읽을 수 있기 때문이다. 사용자가 크기나 타입을 신경쓰지 않고도 모든 요소를 순차적으로 읽을 수 있도록 제공해주는 것이 바로 반복자다. 컨테이너의 요소를 가리키는 객체. 컨테이너의 시작부터 끝까지 이동하면서 요소를 읽거나 쓰기 위해 사용한다.
알고리즘(algorithm)
- 정렬 및 검색하는 알고리즘을 구현한 함수.
- 변경 불가 순차 알고리즘
- 변경 가능 순차 알고리즘
- 정렬 알고리즘
- 범용 수치 알고리즘
기타
- stack: LIFO(Last In First Out) 방식의 컨테이너.
- queue: FIFO(First In First Out) 방식의 컨테이너.
- priority_queue: 우선순위가 있는 큐로, 가장 높은 우선순위를 가진 요소를 우선적으로 꺼낸다.

벡터(Vector)

일반화된 컨테이너 중 가장 많이 사용된다. 필요한 크기만큼 메모리를 자동으로 재할당하여 늘릴 수 있다.(동적 배열) 템플릿 기반으로 타입에 무관함.

초기 생성된 길이만큼 데이터가 꽉 차있을 때 더 넣으려고 시도하면 내부에서 크기를 늘린다.

`vector<T> vectorName;` `vector<int> intVector;` `vector<int> intVector(5);`

배열처럼 인덱스로 요소를 가져올 수 있다.

	for (int i = 0; i < vec.size(); i++) {
		cout << vec[i] << endl;
	}

데크(Deque)

벡터와 유사하나 양쪽 끝에서 데이터를 삽입 삭제할 수 있는 컨테이너. 앞/중간 인덱스에 데이터를 삽입할 경우 모든 요소의 인덱스가 뒤로 밀리면서 성능이 떨어지는 벡터의 단점을 보완하기 위해 만들어진 컨테이너.

`deque<T> dqName; deque<int> dq;`

리스트(List)

이중 연결 리스트로 구현된 컨테이너. 각각의 요소가 포인터로 연결되어있다. 데이터가 물리적으로 인접해 있지 않고, 논리적인 순서를 기억하여 포인터로 이전 또는 다음 노드를 가리키고 있기 때문에 데이터 삽입 및 삭제 속도가 일정하다.

list<T> li; list<int> li;

연결리스트(Linked-List)

요소들이 인접해있는 것이 아니라 메모리 도처에 흩어져서 자신의 이전 또는 다음 요소의 위치를 포인터로 가리키고 있는 리스트. 추상적 순서와 물리적 순서가 일치하는 배열과 달리 연결리스트는 물리적인 순서와 상관이 없다. 임의의 위치에 대한 요소의 삽입 및 삭제 속도가 동일하다.

연결리스트에서 원소는 데이터(값)와 링크(메모리 주소값)를 동시에 가지며 링크는 후행 원소의 주소값이다. 이러한 단위 구조를 노드(node)라고 한다. 각 요소는 데이터 외에 이전/다음 노드의 링크를 추가로 가지고 있어야 한다.

다음 노드의 정보만을 가진 리스트를 단일 연결 리스트(Single Linked List), 이전과 다음 노드의 정보를 둘 다 가지고 있는 리스트를 이중 연결 리스트(Double Linked Llist)라고 한다.

struct Node{
	T value;
	Node* next;
}

#include <iostream>

using namespace std;

struct Node {
	int value;
	Node* next;
};

Node* head;
Node* now;

void InitLinkedList() {
	head = (Node*)malloc(sizeof(Node));
	
	head->value = NULL;
	head->next = NULL;
	now = head;
}

Node* InsertNode(Node* now, int value) {

	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->value = value;
	
	newNode->next = now->next;
	now->next = newNode;

	return newNode;
}

bool DeleteNode(int index) {
	
	Node* prev = head;
	Node* del;

	for (int i = 0; i < index; i++) {
		prev = prev->next;

		if (prev == NULL) {
			return false;
		}
	}

	del = prev->next;
	if (del == NULL) {
		return false;
	}

	prev->next = del->next;
	free(del);

	return true;

}

bool DeleteNode(Node* targetPrev) {

	Node* del; 

	del = targetPrev->next;

	if (del->next == NULL) {
		return false;
	}

	targetPrev->next = del->next;
	free(del);

	return true;

}

void DeleteList() {
	free(head);
	head = NULL;
}

int main() {

	InitLinkedList();

	for (int i = 0; i < 10; i++) {
		InsertNode(now, i + 1);
		now = now->next;
	}

	for (now = head->next; now; now = now->next) {
		cout << now->value << endl;
	}

	cout << endl;

	//bool result = DeleteNode(head);
	bool result = DeleteNode(9);

	cout << endl;

	cout << "result : " << result << endl;
	
	for (now = head->next; now; now = now->next) {
		cout << now->value << endl;
	}

	DeleteList();

}

Set

정렬 연관 컨테이너. 순서가 없고 중복을 허용하지 않는 자료구조. 값을 오름차순으로 정렬한다.

#include <iostream>
#include <set>

using namespace std;

int main() {

	int arr[] =  {1, 2, 3, 2, 5, 6, 3};
	
	
	set<int> scon;

	set<int>::iterator it;

	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
		scon.insert(arr[i]);
	}

	for (it = scon.begin(); it != scon.end(); it++) {
		cout << *it << endl;
	}
	
	return 0;

}

Map

키:값 형태로 하나의 쌍을 이루어 관리된다. 값을 오름차순으로 정렬한다. 검색 속도가 빠르다.

대용량 데이터를 검색할 경우 유리하다.

삽입 및 삭제 시 데이터의 이동이 발생하므로 상대적으로 느리다.

`map<keyType, dataType> m; map<string, int> ageList;`

`first` 는 키, `second` 는 값.

	map<string, int> phoneBook;
	map<string, int>::iterator it;

	string name;

	for (int i = 0; i < sizeof(phoneList) / sizeof(phoneList[0]); i++) {
		phoneBook[phoneList[i].name] = phoneList[i].phone;
	}

	while (true) {
		cout << "종료: [q]";
		cout << "이름을 입력하세요: ";
		cin >> name;

		if (name == "q") {
			break;
		}

		// phoneBook[name]은 value만을 불러오지만,
		// 반복자로 it = phoneBook.find(name);를 사용하면
		// 요소의 주소값을 가져오기 때문에 키와 값을 모두 사용할 수 있다!
		if (phoneBook[name]) {
			cout << "번호는 " << phoneBook[name] << "입니다." << endl;
		}
		else {
			cout << "찾을 수 없습니다.  [" << name << "]" << endl;
		}

	}

해시맵(hashMap)

STL에서는 해시맵을 지원한다. hash 자료구조를 사용하기 때문에 검색 속도가 빠르다.

* `hash_map` 이 deprecated 되었습니다. `unordered_map` 을 사용할 수 있습니다.

unordered_map<string, int> coffee;
coffee["아메리카노"] = 2000;

unordered_map<string, int>::iterator it;

for (it = coffee.begin(); it != coffee.end(); it++) {
	cout << "[" << it->first << "] " << it->second << "원" << endl;
}

	unordered_map<string, vector<string>> devLang;

	vector<string> c;
	c.push_back("C");
	c.push_back("C++");
	c.push_back("C#");

	vector<string> script;

	devLang["C 계열"] = c;

	vector<string> scr;
	scr.push_back("JavaScript");
	scr.push_back("TypeScript");

	devLang["Script 계열"] = scr;

	unordered_map<string, vector<string>>::iterator mapIt;
	vector<string>::iterator it;

	for (mapIt = devLang.begin(); mapIt != devLang.end(); mapIt++) {
		cout << "[" << mapIt->first << "]" << endl;
		for (it = mapIt->second.begin(); it != mapIt->second.end(); it++) {
			cout << *it << " " << endl;
		}

		cout << endl;
	}

[Script 계열]
JavaScript
TypeScript

[C 계열]
C
C++
C#

반복자(Iterator)

컨테이너의 구간에 대해 값을 읽어올 수 있도록 기능을 제공한다. 모든 컨테이너에 동일하게 동작한다.(내부 구조를 모르더라도 같은 함수로 값을 읽을 수 있다.)

`list::iterator listIter; vector::iterator vectorIter;`

포인터와 유사함. `listIter++` 처럼 반복자를 증가시키는 것은 그 다음 요소를 읽어오는 것을 뜻한다.

자료구조의 `begin()` 은 시작 요소를 의미한다. `end()` 는 마지막값이 아니라 마지막값의 다음을 의미한다.

문자열은 다음과 같이 문자 포인터로 각 문자를 읽을 수 있다.

char arr[] = "Hello!";

char* ptr = arr;

while (*ptr) // ptr != NULL
{
    cout << *ptr;
    ptr++;
}

컨테이너도 이처럼 반복자를 사용하면 내부 구조를 모르더라도 동일한 함수를 사용하여 컨테이너 내 포함된 요소를 순차적으로 가리킬 수 있다.

컨테이너의 타입에 따라 반복자를 선언하고 사용할 수 있다.

int intArr[] = { 1, 2, 3, 4, 5 };

vector<int> vec(&intArr[0], &intArr[sizeof(intArr) / sizeof(intArr[0])]);
vector<int>::iterator it;

for (it = vec.begin(); it != vec.end(); it++) {
    cout << *it << " ";
}

list<int> li;
list<int>::iterator it;

for (int i = 0; i < 5; i++) {
    li.push_back(i + 1);
}

for (it = li.begin(); it != li.end(); it++) {
    cout << *it << " ";
}

알고리즘(Algorithm)

컨테이너에 적용할 수 있는 기능들을 체계적으로 정리해둔 함수. 정렬, 검색, 조작 등의 연산을 수행한다. 특정 컨테이너에 종속된 것이 아니라 일반적으로 적용할 수 있음.

ex) `find()` `first`와 `last` 사이에 `value`가 있는지 검사하고 찾는 값이 있다면 해당 위치의 반복자를 리턴한다.

ex) `for_each()` 전 구간을 순회하면서 인자로 받은 함수를 호출한다. `for_each`는 루프를 돌리는 역할만 하므로 구체적인 동작을 하는 함수 객체가 반드시 필요하다. 내부에서 반복자를 사용한다.

ex) `copy()` 컨테이너의 범위값을 대상이 되는 컨테이너에 복사하는 함수.

ex) `sort()` 기본은 오름차순 정렬. 내림차순으로 정렬하려면 `greator<int>()` 를 전달해야함.

	int intArr[] = { 1, 2, 3, 4, 5 };

	vector<int> vec(&intArr[0], &intArr[sizeof(intArr) / sizeof(intArr[0])]);
	vector<int>::iterator it;

	if (find(vec.begin(), vec.end(), 5) != vec.end()) {
		cout << "Found Five!";
	}
	else {
		cout << "Not Found";
	}

[C++] 템플릿(Template)

벼리01 — Thu, 29 Aug 2024 12:13:35 +0900

템플릿

함수나 클래스를 개별적으로 다시 작성하지 않아도, 여러 자료형으로 사용할 수 있도록 만들어놓은 틀. 여러 타입에서 동작할 수 있는 함수를 찍어내는 틀. 다양한 타입에 대해서 하나의 함수만 정의하여 사용할 수 있다.

이러한 형태의 함수가 있다는 것만 약속해두고, 함수가 호출되는 시점에 인자의 타입에 따라 실제 함수인 템플릿 인스턴스 함수를 만든다.(컴파일러가 전달된 타입을 검사하여 그에 해당하는 함수를 생성한다.)

// 함수 템플릿
template <typename T> 
T FunctionTemplate(T a, T b) {
	...
}

// 클래스 템플릿
template <class T>
class MyClass {

public: 
    MyClass(T a) {
        this->a = a;
    }

private :
	T a;
}

함수 템플릿(Function Template)

범용형을 다룰 수 있는 함수의 정의. 어떤 타입이든 이러한 형태를 가진다고 사전에 정의해두는 틀.

두 수를 비교하는 함수 `Max()`를 정의한다. 이때 정수가 아닌 자료형이 들어올 수 있으므로 오버로딩 해야한다.

int Max(int a, int b) {
	return a > b ? a :  b;
}

double Max(double a, double b) {
	return a > b ? a : b;
}

char Max(char a, char b) {
	return a > b ? a : b;
}

매개변수 타입과 리턴 타입만 다를 뿐 함수의 내부가 모두 중복되는 것을 볼 수 있다.

이와 같이 타입만 빼고 코드가 모두 동일할 때, 오버로딩 대신 템플릿을 정의할 수 있다.

template <typename T> 
T Max(T a, T b) {
	return a > b ? a : b;
}

클래스 템플릿(Class Template)

간단한 스택을 구현해보자. 이때 어떤 자료형이 들어올지 알 수 없으므로 템플릿으로 클래스를 정의한다.

template <class T>
class MyStack {

public:
	MyStack(int size) {
		this->ptr = new T[size];
		this->size = size;
	}

	~MyStack() {
		delete[] ptr;
	}

	void Push(T a) {
		*ptr++ = a;
	}

	T Pop() {
		T temp = *--ptr;
		*ptr = NULL;

		return temp;
	}

	int Size() const {
		return this->size;
	}

private:
	T* ptr;
	int size;
};

int main() {

	MyStack<int> testStack(5);
	testStack.Push(1);
	testStack.Push(15);
	testStack.Push(29);

	cout << testStack.Pop() << endl;
	cout << testStack.Pop() << endl;
	cout << testStack.Pop() << endl;

	return 0;
}


// 출력값
// 29
// 15
// 1

서로 다른 타입을 2개 이상 갖는 템플릿

범용 타입을 위해 타입 이름을 `T` 로 정의했었다. 이때 `T` 는 치환되는 단어와 같으므로 다음과 같이 두 개 이상 정의할 수 있다.

template <class Key, class Value>
class Map {
public:
    Map() {}

    void insert(const Key& key, const Value& value) {

    }

    bool find(const Key& key, Value& value) const {
		...
    }


    bool delete(const Key& key) {
		...
    }
    
private:
	...
};

[C++] 상속(Inheritance)

벼리01 — Thu, 29 Aug 2024 09:29:05 +0900

상속

코드의 중복을 줄이고 재사용성을 높이기 위해 클래스 간의 상속 관계를 정의할 수 있다.

예를 들어 `name`과 `address`를 갖는 `RagularEmployee`와 `TemporaryEmployee`가 있을 때, 둘을 ` Employee`로 일반화하여 정의하고 상속받아 사용할 수 있다.

#include <iostream>

using namespace std;

class Employee {

public : 
	Employee() {

	}

	Employee(const char* name, const char* address) {
		this->name = new char[strlen(name) + 1];
		this->address = new char[strlen(address) + 1];

		strcpy_s(this->name, strlen(name) + 1, name);
		strcpy_s(this->address, strlen(address) + 1, address);
	}

	~Employee() {
		delete[] name;
		delete[] address;
	}

	char* getName() {
		return this->name;
	}

	char* getAddress() {
		return this->address;
	}

	void print() {
		cout << "이름: " << this->getName() << ", 주소: " << this-> getAddress() << endl;
	}

protected:
	char* name;
	char* address;
};

class RegularEmployee : public Employee {

private :
	int 연봉;

};

class TemporaryEmployee : public Employee {

private :
	int 주급;
};

둘은 클래스 내부에 또 다시 속성을 정의하지 않더라도 상속을 받았기 때문에 이름과 주소를 가진다. 멤버 함수도 함께 상속받으므로 `getter()` 와 `print()` 도 사용할 수 있다.

이때 `private` 으로 선언된 멤버 변수는 상속이 되더라도 접근 제한을 받기 때문에, 만약 자식에게 접근 권한을 주고 싶다면 `protected` 로 설정해야한다.

객체 생성 시에는 무조건 부모의 생성자를 먼저 호출한다.(부모가 존재하는지 확인한 후 부모를 먼저 만들기 때문이다.) 부모의 어떤 생성자를 호출할지 명시하지 않으면 무조건 기본 생성자를 호출한다.

원하는 부모의 생성자를 사용하기 위해서는 부모의 생성자 중 어떤 생성자를 호출할지 생성자의 시그니처에 명시해야한다.

객체가 스택에 생성되기 때문에, 하위 클래스가 먼저 소멸되고 상위 클래스가 소멸된다. 이때 자식 클래스의 소멸자를 먼저 호출하고, 부모 클래스의 소멸자를 호출한다.

class RegularEmployee : public Employee {

public : 

	RegularEmployee() {
		cout << "reg 디폴트 생성자 " << endl;
	}

	RegularEmployee(const char* name, const char* address, double salary) 
	: Employee(name, address) {
		cout << "reg 인자 세개 생성자 " << endl;
		
		this->salary = salary;
	}

	~RegularEmployee() {
		cout << "rag 소멸자 호출" << endl;
	}

	double PayCheck() {
		return this->salary;
	}

private :
	double salary;

};

void main() {

	Employee e("회사원", "회사원 주소");
	e.print();

	RegularEmployee re("정규직원", "정규직원 주소", 5500);
	cout << re.PayChack() << endl;

	TemporaryEmployee te("계약직", "계약직 주소", 10, 20);
	cout << te.PayCheck() << endl;
}

emp 인자 두개 생성자
이름: 회사원, 주소: 회사원 주소
emp 인자 두개 생성자
reg 인자 세개 생성자
5500
emp 인자 두개 생성자
temp 인자 세개 생성자
2400
temp 소멸자 호출
emp 소멸자 호출
rag 소멸자 호출
emp 소멸자 호출
emp 소멸자 호출

다형성(Polymorphism)

사전: 같은 종의 생물이면서도 어떤 형태나 성질이 다양하게 나타나는 현상. 'poly(많은)' 과 'morphism(형태)'의 합성어.

하나의 객체를 다른 자료형의 변수로 참조하여 다양한 결과를 얻어낼 수 있는 성질. 클래스가 상속 관계에 있을 때 나타나는 다채로운 성질을 말한다.

동적 결합/동적 바인딩(Dynamic Binding)

실행 도중에 결합(바인딩)이 이루어지는 것을 동적 결합이라고 한다. 동적 바인딩으로 인해 포인터가 어떤 타입이든 상관 없이 그 실제 객체를 기준으로 함수를 호출한다. 이 동적 바인딩 덕분에 다형성이 적용되는 것!

오버라이딩(Overriding)

사전적 의미: '~에 덮어쓰다.', '~에 우선한다.'

부모 클래스로부터 상속 받은 멤버 함수를 자식 클래스에서 재정의하여 새로운, 또는 수정 및 확장된 기능을 만드는 것. 함수의 시그니처가 동일해야한다. (이름 동일, 매개변수의 타입 및 개수 동일, 반환 타입 동일)

부모 클래스의 객체 포인터는 자식 클래스 객체에 접근이 가능하다. 즉, 부모 타입으로 선언된 포인터로 자식 타입의 객체를 다룰 수 있다.

가상 함수(Virtual Function)

다형성을 지원하기 위해 자식 클래스의 객체가 재정의한 함수로 동작할 수 있도록 하는 것. C++에서는 함수를 가상함수로 등록하지 않으면 자식 객체에서 함수를 오버라이딩 했더라도, 부모 타입의 변수로 자식 객체를 참조했을 때 부모 타입에 정의된 함수로 동작한다.

가상 함수가 포함된 클래스는 추상 클래스로 객체를 생성할 수 없다.

자바에서는 모든 함수가 가상함수로 선언되어 있기 때문에, 부모 타입의 변수로 자식 타입의 객체를 참조하더라도 자식 객체에서 재정의된 함수로 동작한다.

가상함수 미사용

#include <iostream>

class Base {
public:
    void display() {  // 비가상 함수
        std::cout << "Base display" << std::endl;
    }
};

class Derived : public Base {
public:
    void display() {  // 함수 재정의 (오버라이딩이 아님)
        std::cout << "Derived display" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();  // 부모 타입 포인터로 자식 객체 참조
    basePtr->display();  // Base의 display 호출
    delete basePtr;
    return 0;
}

가상함수 사용

#include <iostream>

class Base {
public:
    virtual void display() {
        std::cout << "Base display" << std::endl;
    }
};

class Derived : public Base {
public:
    void display() override {  // 가상 함수 재정의
        std::cout << "Derived display" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();  // 부모 타입 포인터로 자식 객체 참조
    basePtr->display();  // Derived의 display 호출
    delete basePtr;
    return 0;
}

C#에서의 가상함수

가상함수 미사용

using System;

class Base
{
    public void Display()  // 비가상 메서드
    {
        Console.WriteLine("Base display");
    }
}

class Derived : Base
{
    public new void Display()  // 메서드 숨기기
    {
        Console.WriteLine("Derived display");
    }
}

class Program
{
    static void Main()
    {
        Base baseRef = new Derived();  // 부모 타입 참조로 자식 객체 참조
        baseRef.Display();  // Base의 Display 호출
    }
}

가상함수 사용

using System;

class Base
{
    public virtual void Display()  // 가상 메서드로 변경
    {
        Console.WriteLine("Base display");
    }
}

class Derived : Base
{
    public override void Display()  // 재정의된 가상 메서드
    {
        Console.WriteLine("Derived display");
    }
}

class Program
{
    static void Main()
    {
        Base baseRef = new Derived();  // 부모 타입 참조로 자식 객체 참조
        baseRef.Display();  // Derived의 Display 호출
    }
}

상속 예시

#include <iostream>

using namespace std;

class Employee {

public : 
	Employee() {
		cout << "emp 디폴트 생성자 " << endl;
	}

	Employee(const char* name, const char* address) {
		cout << "emp 인자 두개 생성자 " << endl;
		this->name = new char[strlen(name) + 1];
		this->address = new char[strlen(address) + 1];

		strcpy_s(this->name, strlen(name) + 1, name);
		strcpy_s(this->address, strlen(address) + 1, address);
	}

	~Employee() {
		cout << "emp 소멸자 호출" << endl;
		delete[] name;
		delete[] address;
	}


	char* getName() {
		return this->name;
	}

	char* getAddress() {
		return this->address;
	}

	void Print() {
		cout << "이름: " << this->getName() << ", 주소: " << this-> getAddress() << endl;
	}

	virtual double PayCheck() const = 0;

protected :
	char* name;
	char* address;
};

class RegularEmployee : public Employee {


public : 

	RegularEmployee() {
		cout << "reg 디폴트 생성자 " << endl;
	}

	RegularEmployee(const char* name, const char* address, double salary)
		: Employee(name, address) {
		cout << "reg 인자 세개 생성자 " << endl;
		
		this->salary = salary;
	}

	~RegularEmployee() {
		cout << "rag 소멸자 호출" << endl;
	}

	double PayCheck() const override {
		return salary * 12;
	}

private :
	double salary;

};

class TemporaryEmployee : public Employee {


public : 

	TemporaryEmployee() {
		cout << "temp 디폴트 생성자 " << endl;
	}

	TemporaryEmployee(const char* name, const char* address, double dailyPayCheck, int days)
		: Employee(name, address) {
		cout << "temp 인자 세개 생성자 " << endl;

		this->dailyPayCheck = dailyPayCheck;
		this->days = days;
	}


	~TemporaryEmployee() {
		cout << "temp 소멸자 호출" << endl;
	}

	double PayCheck() const override {
		return this->dailyPayCheck * days * 12;
	}

private :
	double dailyPayCheck;
	int days;
};

class SalesMan : public RegularEmployee {

public : 

	SalesMan() {
		cout << "sales 디폴트 생성자 " << endl;
	}

	SalesMan(const char* name, const char* address, double salary, double allowance) 
		: RegularEmployee(name, address, salary) {
		cout << "sales 인자 네개 생성자 " << endl;
		this->allowance = allowance;
	}

	~SalesMan() {
		cout << "sales 소멸자 호출" << endl;
	}

	double PayCheck() const override {
		return RegularEmployee::PayCheck() + (allowance * 12);
	}

private:
	double allowance;
};

// Employee 관리 클래스
class Department {
public :
	Department() {
		this->count = 0;
	}

	~Department() {
	}

	// 객체를 전달 인자로 받아 객체 배열에 넣어 관리
	void Insert(Employee& emp) {
		this->emp[count] = &emp;
		count++;
	}

	// 현재 관리 중인 객체의 급여 출력
	void Print() const {
		for (int i = 0; i < count; i++) {
			cout <<"[" << this->emp[i]->getName() << "] ";
			cout << this->emp[i]->PayCheck() << endl;
		}
	}

private:
	Employee* emp[10];
	int count;
};


void main() {

	//Employee e("회사원", "회사원 주소");
	//e.print();

	RegularEmployee re("정규직원", "정규직원 주소", 550);
	//cout << re.PayCheck() << endl;

	TemporaryEmployee te("계약직", "계약직 주소", 10, 20);
	//cout << te.PayCheck() << endl;

	SalesMan sm("jung", "분당", 300, 50);
	//cout << sm.PayCheck() << endl;

	/*Employee* salesMan = (Employee*) new SalesMan("정영업", "분당", 500, 50);
	cout << salesMan->PayCheck() << endl;*/

	Department dpt;
	dpt.Insert(re);
	dpt.Insert(te);
	dpt.Insert(sm);

	dpt.Print();

}

참고

[C++] 동적 바인딩, 정적 바인딩

동적 정적 바인딩 사전 준비 * 먼저 다형성에 대한 개념을 알고 있어야 한다. https://licktwice.tistory.com/59https://licktwice.tistory.com/59 [JAVA]자바 - 다형성 Polymorphism 다형성 Polymorphism OOP의 4대 특성 * 다형

licktwice.tistory.com

[CSS] Flex box

벼리01 — Wed, 28 Aug 2024 12:05:44 +0900

Flex box

행과 열 형태로 자식 요소를 배치하는 레이아웃 속성. 부모 요소 내부에 포함된 자식 요소들을 세로, 가로 중심부에 정렬하거나, 자식 요소의 너비를 동일하게 설정할 수 있다.

속성

<body>
    <div class="wrap">
        <div class="parent">
            <div class="child"></div>
            <div class="child"></div>
            <div class="child"></div>
        </div>

    </div>
</body>

html, body{
    margin : 0;
    padding: 0;
}

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;

    display: flex;
    flex-direction: column;
    align-items: center;
    
}

.child{
    width: 100px;
    height: 100px;
    border: 1px solid #000;
    background-color: wheat;
}

초기 상태

flex-direction

위와 같이 부모 요소 내에 여러 자식 요소가 있을 때, 스타일에 `display: flex` 를 작성하면 flex box로 요소를 다룰 수 있다.

기본적으로 자식 요소가 가로로 정렬된다.

`flex-direction` 을 열 또는 행 방향으로 설정할 수 있다. 기본 값은 `flex-direction: row`으로 속성값을 작성하지 않으면 열 방향으로 설정된다.

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;
    display: flex;

}

flex-direction : row(default)

flex-direction: column;

align-items

현재 flex-box의 방향이 열(row)로 되어있으므로, `align-items: center` 를 적용하면 수직 정렬할 수 있다.

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;

    display: flex;
    align-items: center;
    
}

align-items: center

현재 방향이 열(row)이므로, `align-item : flex-end`를 설정하면 부모 요소의 가장 끝단에 배치할 수 있다.

기본값은 `flex-start` (상단 고정)

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;

    display: flex;
    align-items: flex-end;
}

align-item : flex-end

justify-content

현재 flex-box 방향이 열(row)로 되어있으므로, `justify-content: center` 를 적용하면 수평 정렬할 수 있다.

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;

    display: flex;
    justify-content: center;
}

row일 때 justify-content : center

현재 방향이 열(row)이므로, `justify : flex-end`를 설정하면 부모 요소의 가장 끝단에 배치할 수 있다.

기본값은 `flex-start` (상단 고정)

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;

    display: flex;
    justify-content: flex-end;
}

justify : flex-end

현재 방향이 열(row)이므로, `justify-content: space-around;`를 작성하면 부모 요소에 맞춰 좌우 마진을 동일하게 설정한다.

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;

    display: flex;
    justify-content: space-around;
}

justify-content: space-around

현재 방향이 열(row)이므로, `justify-content: space-between;`를 작성하면 요소 사이의 좌우 공간을 동일하게 배치한다. 단, 맨 처음 요소와 마지막 요소는 마진 없이 딱 붙인다.

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;

    display: flex;
    justify-content: space-between;
}

justify-content: space-between

현재 방향이 열(row)이므로, `justify-content: space-around;` 를 작성하면 요소 사이의 공간을 동일하게 배치한다. 이때 `justify-content: space-between;`와 달리 맨 첫 요소와 마지막 요소의 좌우 여백도 동일한 공간으로 맞춘다.

.parent{
    width: 500px;
    height: 600px;
    background-color: pink;

    display: flex;
    justify-content: space-around;
}

justify-content: space-around;