예쁜 인쇄 std

ProgramingTip

예쁜 인쇄 std :: tuple

bestdevel 2020. 10. 12. 07:56

예쁜 인쇄 std :: tuple

이 예쁘게 인쇄되는 STL 컨테이너 에 대한 이전 질문에 대한 후속 조치로 , 우리는 매우 우아하고 완벽하게 일반적인 솔루션을 개발할 수 있습니다.

이 다음 단계에서는 std::tuple<Args...>가변 템플릿을 사용하여에 대한 pretty-printing을 포함하고 싶습니다 (C ++ 11입니다). 의 경우 std::pair<S,T>간단히

std::ostream & operator<<(std::ostream & o, const std::pair<S,T> & p)
{
  return o << "(" << p.first << ", " << p.second << ")";
}

튜플을 인쇄하는 구조는 무엇입니까?

다양한 템플릿 인수 스택 압축을 풀고 배치를 전달하고 SFINAE를 사용하여 마지막 요소에있을 때 발견했지만 성공하지 않았습니다. 나는 내 깨진 코드로 당신에게 부담을주지 않을 것입니다. 문제 설명은 충분히 간단합니다. 기본적으로 다음과 같은 동작을 원합니다.

auto a = std::make_tuple(5, "Hello", -0.1);
std::cout << a << std::endl; // prints: (5, "Hello", -0.1)

이전 질문과 동일한 수준의 일반성 (char / wchar_t, 쌍 구분 기호)을 포함하면 보너스 포인트!

예, 지수 ~

namespace aux{
template<std::size_t...> struct seq{};

template<std::size_t N, std::size_t... Is>
struct gen_seq : gen_seq<N-1, N-1, Is...>{};

template<std::size_t... Is>
struct gen_seq<0, Is...> : seq<Is...>{};

template<class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch,Tr>& os, Tuple const& t, seq<Is...>){
  using swallow = int[];
  (void)swallow{0, (void(os << (Is == 0? "" : ", ") << std::get<Is>(t)), 0)...};
}
} // aux::

template<class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr>& os, std::tuple<Args...> const& t)
    -> std::basic_ostream<Ch, Tr>&
{
  os << "(";
  aux::print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());
  return os << ")";
}

이데온의 라이브 예.

구분 기호의 경우 다음 부분 전문화를 추가하십시오.

// Delimiters for tuple
template<class... Args>
struct delimiters<std::tuple<Args...>, char> {
  static const delimiters_values<char> values;
};

template<class... Args>
const delimiters_values<char> delimiters<std::tuple<Args...>, char>::values = { "(", ", ", ")" };

template<class... Args>
struct delimiters<std::tuple<Args...>, wchar_t> {
  static const delimiters_values<wchar_t> values;
};

template<class... Args>
const delimiters_values<wchar_t> delimiters<std::tuple<Args...>, wchar_t>::values = { L"(", L", ", L")" };

그리고 변경 operator<<및 print_tuple그에을 :

template<class Ch, class Tr, class... Args>
auto operator<<(std::basic_ostream<Ch, Tr>& os, std::tuple<Args...> const& t)
    -> std::basic_ostream<Ch, Tr>&
{
  typedef std::tuple<Args...> tuple_t;
  if(delimiters<tuple_t, Ch>::values.prefix != 0)
    os << delimiters<tuple_t,char>::values.prefix;

  print_tuple(os, t, aux::gen_seq<sizeof...(Args)>());

  if(delimiters<tuple_t, Ch>::values.postfix != 0)
    os << delimiters<tuple_t,char>::values.postfix;

  return os;
}

과

template<class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple(std::basic_ostream<Ch, Tr>& os, Tuple const& t, seq<Is...>){
  using swallow = int[];
  char const* delim = delimiters<Tuple, Ch>::values.delimiter;
  if(!delim) delim = "";
  (void)swallow{0, (void(os << (Is == 0? "" : delim) << std::get<Is>(t)), 0)...};
}

C ++ 11 (gcc 4.7)에서 잘 작동합니다. 내가 고려하지 않은 몇 가지 함정이 확신하지만 코드는 복잡하지 않다고 생각합니다. 이상 할 수있는 유일한 것은 마지막 요소에 도달했을 때 종료하는 "가드"구조체 tuple_printer입니다. 또 다른 이상한 점은 Types 유형 팩의 유형 수를 반환하는 sizeof ... (유형) 일 수 있습니다. 마지막 요소의 수준을 결정하는 데 사용됩니다 (크기 ... (유형) -1).

template<typename Type, unsigned N, unsigned Last>
struct tuple_printer {

    static void print(std::ostream& out, const Type& value) {
        out << std::get<N>(value) << ", ";
        tuple_printer<Type, N + 1, Last>::print(out, value);
    }
};

template<typename Type, unsigned N>
struct tuple_printer<Type, N, N> {

    static void print(std::ostream& out, const Type& value) {
        out << std::get<N>(value);
    }

};

template<typename... Types>
std::ostream& operator<<(std::ostream& out, const std::tuple<Types...>& value) {
    out << "(";
    tuple_printer<std::tuple<Types...>, 0, sizeof...(Types) - 1>::print(out, value);
    out << ")";
    return out;
}

cppreference에 대한 구현 이 아직 여기에 게시되지 않은 것에 놀랐습니다. 그래서 후대를 위해 할 것입니다. 문서에 숨겨져 있기 std::tuple_cat때문에 찾기가 쉽지 않습니다. 다른 솔루션과 많은 가드를 사용하지만 사용기로 더 간단하고 생각합니다.

#include <iostream>
#include <tuple>
#include <string>

// helper function to print a tuple of any size
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static void print(const Tuple& t) 
    {
        TuplePrinter<Tuple, N-1>::print(t);
        std::cout << ", " << std::get<N-1>(t);
    }
};

template<class Tuple>
struct TuplePrinter<Tuple, 1> {
    static void print(const Tuple& t) 
    {
        std::cout << std::get<0>(t);
    }
};

template<class... Args>
void print(const std::tuple<Args...>& t) 
{
    std::cout << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
// end helper function

그리고 테스트 :

int main()
{
    std::tuple<int, std::string, float> t1(10, "Test", 3.14);
    int n = 7;
    auto t2 = std::tuple_cat(t1, std::make_pair("Foo", "bar"), t1, std::tie(n));
    n = 10;
    print(t2);
}

다수 :

(10, 테스트, 3.14, Foo, 바, 10, 테스트, 3.14, 10)

라이브 데모

C ++ 17에서는 표현식 접어 특히 단항 왼쪽, 접기 를 활용하여 코드를 조금 더 적게 사용하여이를 수행 할 수 있습니다 .

template<class TupType, size_t... I>
void print(const TupType& _tup, std::index_sequence<I...>)
{
    std::cout << "(";
    (..., (std::cout << (I == 0? "" : ", ") << std::get<I>(_tup)));
    std::cout << ")\n";
}

template<class... T>
void print (const std::tuple<T...>& _tup)
{
    print(_tup, std::make_index_sequence<sizeof...(T)>());
}

라이브 데모 출력 :

(5, 안녕하세요, -0.1)

주어진

auto a = std::make_tuple(5, "Hello", -0.1);
print(a);

설명

우리의 단항 왼쪽 폴드는

... op pack

여기서 op우리의 시나리오에서 콤마 연산자와 pack같은 팽창 상황에서 우리 튜플을 포함하는 식이다 :

(..., (std::cout << std::get<I>(myTuple))

그래서 다음과 같은 튜플이 권한 부여 :

auto myTuple = std::make_tuple(5, "Hello", -0.1);

그리고 그 값이 유형이 아닌 템플릿으로 지정된 값 (위 코드 참조)std::integer_sequence

size_t... I

그런 다음 표현

(..., (std::cout << std::get<I>(myTuple))

확장됩니다

((std::cout << std::get<0>(myTuple)), (std::cout << std::get<1>(myTuple))), (std::cout << std::get<2>(myTuple));

어느 것이 인쇄됩니다

5Hello-0.1

끔찍하기 때문에 첫 번째 요소가 아닌 한 먼저 인쇄 할 쉼표 구분 기호를 추가 할 더 많은 트릭을 수행해야합니다.

작업을 수행하기, 우리는 수정 pack인쇄 스크롤 식의 일부를 " ,"현재의 설계는 경우에 I, 제 소재 따라서 (I == 0? "" : ", ")부 ^* :

(..., (std::cout << (I == 0? "" : ", ") << std::get<I>(_tup)));

그리고 이제 우리는

5, 안녕하세요, -0.1

더 멋지게 시청 (참고 : 이 답변 과 출력을 원했습니다 )

^{* 참고 : 쉼표 구분은 제가 사용하는 것보다 다양한 방법으로 할 수 있습니다. 에는에보기 처음 대해 테스트하여 이전 이 아닌 뒤 6 조건부로 쉼표를 추가 했지만 너무 길어서 대신에 대해 테스트 했지만 결국 Xeo를 복사 하여 얻은 결과를 얻었습니다.std::tuple_size<TupType>::value - 1sizeof...(I) - 1}

Bjarne Stroustrup의 C ++ 프로그래밍 언어 (817 페이지) 에 대한 예제를 기반으로합니다 .

#include <tuple>
#include <iostream>
#include <string>
#include <type_traits>
template<size_t N>
struct print_tuple{
    template<typename... T>static typename std::enable_if<(N<sizeof...(T))>::type
    print(std::ostream& os, const std::tuple<T...>& t) {
        char quote = (std::is_convertible<decltype(std::get<N>(t)), std::string>::value) ? '"' : 0;
        os << ", " << quote << std::get<N>(t) << quote;
        print_tuple<N+1>::print(os,t);
        }
    template<typename... T>static typename std::enable_if<!(N<sizeof...(T))>::type
    print(std::ostream&, const std::tuple<T...>&) {
        }
    };
std::ostream& operator<< (std::ostream& os, const std::tuple<>&) {
    return os << "()";
    }
template<typename T0, typename ...T> std::ostream&
operator<<(std::ostream& os, const std::tuple<T0, T...>& t){
    char quote = (std::is_convertible<T0, std::string>::value) ? '"' : 0;
    os << '(' << quote << std::get<0>(t) << quote;
    print_tuple<1>::print(os,t);
    return os << ')';
    }

int main(){
    std::tuple<> a;
    auto b = std::make_tuple("One meatball");
    std::tuple<int,double,std::string> c(1,1.2,"Tail!");
    std::cout << a << std::endl;
    std::cout << b << std::endl;
    std::cout << c << std::endl;
    }

다수 :

()
("One meatball")
(1, 1.2, "Tail!")

AndyG 코드 기반, C ++ 17 용

#include <iostream>
#include <tuple>

template<class TupType, size_t... I>
std::ostream& tuple_print(std::ostream& os,
                          const TupType& _tup, std::index_sequence<I...>)
{
    os << "(";
    (..., (os << (I == 0 ? "" : ", ") << std::get<I>(_tup)));
    os << ")";
    return os;
}

template<class... T>
std::ostream& operator<< (std::ostream& os, const std::tuple<T...>& _tup)
{
    return tuple_print(os, _tup, std::make_index_sequence<sizeof...(T)>());
}

int main()
{
    std::cout << "deep tuple: " << std::make_tuple("Hello",
                  0.1, std::make_tuple(1,2,3,"four",5.5), 'Z')
              << std::endl;
    return 0;
}

출력 포함 :

deep tuple: (Hello, 0.1, (1, 2, 3, four, 5.5), Z)

여기에 또 다른 구현이 있습니다.

https://github.com/galaxyeye/atlas/blob/master/atlas/io/tuple.h

테스트 코드 :

https://github.com/galaxyeye/atlas/blob/master/libs/serialization/test/tuple.cpp

즐겨 :)

@Kerrek SB가 제안한 빈 튜플에 대한 전문화를 포함하여 @Tony Olsson과 유사한 또 다른 하나입니다.

#include <tuple>
#include <iostream>

template<class Ch, class Tr, size_t I, typename... TS>
struct tuple_printer
{
    static void print(std::basic_ostream<Ch,Tr> & out, const std::tuple<TS...> & t)
    {
        tuple_printer<Ch, Tr, I-1, TS...>::print(out, t);
        if (I < sizeof...(TS))
            out << ",";
        out << std::get<I>(t);
    }
};
template<class Ch, class Tr, typename... TS>
struct tuple_printer<Ch, Tr, 0, TS...>
{
    static void print(std::basic_ostream<Ch,Tr> & out, const std::tuple<TS...> & t)
    {
        out << std::get<0>(t);
    }
};
template<class Ch, class Tr, typename... TS>
struct tuple_printer<Ch, Tr, -1, TS...>
{
    static void print(std::basic_ostream<Ch,Tr> & out, const std::tuple<TS...> & t)
    {}
};
template<class Ch, class Tr, typename... TS>
std::ostream & operator<<(std::basic_ostream<Ch,Tr> & out, const std::tuple<TS...> & t)
{
    out << "(";
    tuple_printer<Ch, Tr, sizeof...(TS) - 1, TS...>::print(out, t);
    return out << ")";
}

참고 URL : https://stackoverflow.com/questions/6245735/pretty-print-stdtuple

'ProgramingTip' 카테고리의 다른 글

"계속해서 아무 키나 누르시겠습니까?"를 시뮬레이션하는 방법 (0)	2020.10.12
Octave보다 MATLAB을 선호하는 이유 / 언제? (0)	2020.10.12
CSS 선택기 (ID에 텍스트 일부 포함) (0)	2020.10.12
Hibernate Query.list ()를 List로 캐스팅하는“적절한”방법은 무엇입니까? (0)	2020.10.12
특정 파일 형식을 제외하고 특정 폴더 아래의 모든 파일을 재귀 무시합니다. (0)	2020.10.12

현재글예쁜 인쇄 std :: tuple

bestdevel

예쁜 인쇄 std :: tuple

예쁜 인쇄 std :: tuple

설명

'ProgramingTip' 카테고리의 다른 글

'ProgramingTip'의 다른글

티스토리툴바

예쁜 인쇄 std :: tuple

예쁜 인쇄 std :: tuple

설명

'ProgramingTip' 카테고리의 다른 글

'ProgramingTip'의 다른글

관련글

티스토리툴바