2014-04-29 21:07:52 blood_flowing 阅读数 4655

0  C++11


C++11又称为C++0x是新的C++语言的标准,发布于2011年。新的标准取代了2003年发布的C++03,也为C++带来了些许改进。

1 关键词auto修订


一门语言如果太啰嗦了,不仅会为阅读带来障碍,而且还是许多错误的根源。所以从C语言继承而来的关键词auto在C++11中有了新的定义,可以进行自动类型推断。
例如:
//  C++03 方式
for (std::vector<int>::const_iterator ci = v.begin(); ci != v.end(); ++ci);

//  C++11 方式
for (auto ci = v.cbegin(); ci != v.cend(); ++ci);
// 注意 cbegin() 和 cend() 返回一个 const_iterator
需要谨慎的一些应用。
auto x = 10.0;
// 如果将 `10.0' 变换为 `10', x 将变为一个整型变量
// 此处可能会给依赖于它的重载函数带来困扰
// 因此,建议1:利用auto消除繁琐而不是用来保持一致性

for (auto i = 0ul; i < v.size(); ++i);
// 此处 auto i = 0ul 相当于 `unsigned long int i=0'
// 建议 2: 不要针对特定类型使用auto,因为那样做会给你带来不少问题

// 建议 3: 针对建议1和2,不要对常量使用auto


2  for()的循环范围


迭代操作在STL中是很常见的。C++11提供了一个专门的for函数来简化那些以begin()、end()为参数并返回迭代器的函数。这种新的方式对于C的数组同样有效。
例子:
// the C++03 way
for (std::vector<int>::iterator i = v.begin(); i != v.end(); ++i);

// the C++11 way
for (int &item: v);
// item 将从v的begin()执行到v的end()
// 注意这里的引用,它允许我们改变v中的内容

for (const int &item: v); // 这时不能改变内容,引用可以提速
for (int item: v); // 通过传值,不能改变v中内容

3 初始化列表


C++03中的容器不能像C中的数组那样利用列表初始化,这个问题在C++11中得到改进。
例如:
// C arrays
char   array1[] = {'A', 'B'};
double array2[] = {32.0, 6.003, -0.1};

// C++03 vectors

std::vector<char> cpp03vector1;
cpp03vector1.push_back('A');
cpp03vector1.push_back('B');

std::vector<double> cpp03vector2(3);
cpp03vector2[0] = 32.0;
cpp03vector2[1] = 6.003;
cpp03vector2[2] = -0.1;

// C++11 vectors
std::vector<char>   cpp11vector1 = {'A', 'B'};
std::vector<double> cpp11vector2 = {32.0, 6.003, -0.1};
// or...
std::vector<char>   cpp11vector3{'A', 'B'};
std::vector<double> cpp11vector4{32.0, 6.003, -0.1};
// 注意这种方式也适用于STL中的其他容器, 不仅仅是std::vector

列表初始化也可以运用在更复杂的结构中,如下所示:
#include <map>
#include <string>
#include <vector>
#include <utility>

using namespace std;

map<string, vector<pair<string, int>>> name_languages_year {
    {"Dennis Ritchie",    {{"B",      1969}, {"C",        1973}}},
    {"Niklaus Wirth",     {{"Pascal", 1970}, {"Modula-2", 1973}, {"Oberon", 1986}}},
    {"Bjarne Stroustrup", {{"C++",    1983}}},
    {"Walter Bright",     {{"D",      1999}}}
};
// 注意为了匹配template  列表的嵌套方式。

cout << name_languages_year["Niklaus Wirth"].at(0).first << endl; // prints `Pascal'

// adds a new entry to the map
name_languages_year["John McCarthy"] = {
    {"Lisp", 1958}
};
// 注意此处并没有显式的类型

4 C++数组


貌似这块儿是C++11添加的新的功能。
C++11提供了std::array,目的是来取代C中的数组。这是个尺寸可变的轻量级数组,使用的时候效果与std::vector差不多。
例子:
#include <array>

// C arrays
char  carray1[] = "Abc"; // caution, an unseen '\0' is added to the end
float carray2[] = {0.2f, 33.33f};

// C++ arrays
std::array<char, 3>  cpparray1{{'A', 'b', 'c'}};
std::array<float, 2> cpparray2{{0.2f, 33.33f}};
// 关注点 1: 尺寸在编译的时候推导
// 关注点 2:  数组尺寸不可变
// 关注点 3: 括号里的类型由参数列表决定


// 新旧数组的对比

std::cout << sizeof carray1 - 1; // -1 因为额外的 '\0'
std::cout << sizeof carray2 / sizeof (float); // 元素的个数 != 字节数
std::cout << cpparray1.size();
std::cout << cpparray2.size();

carray2[-5] = 0.1f; // 下溢
cpparray2.at(-5) = 0.1f; // throws std::out_of_range 异常

//  C++ arrays 比 C arrays好的原因有很多,从上述代码可见一斑

5 少许修正


C++03中的一些小缺陷在C++11中得到了修正。
例如:
 set<vector<int>>在C++11中可以编译了。(注意最后两个尖括号之间没有空间哦)
2  std::string 有了front和back成员函数。
3  文件流可以接受std::string类型的文件名,意味着我们不再需要使用可笑的c_str()进行转换。
4 可以很方便的将数值想std::string进行类型转换。通过以下重载函数:
   string to_string(int) 
   string to_string(float) 
   string to_string(double) 
   ...

6 支持C++11的编译器


1 GNU C++ 编译器需要加入 -std=c++0x 来编译 C++11 代码。
2 Visual Studio 2010部分支持C++11特性。
3 Visual Studio 201X(V11)仍然只对C ++11的功能部分支持。


2018-04-12 10:44:18 valada 阅读数 3942

内容简介

到目前为止,C++ 仍然是计算机编程领域的经典语言之一,C++ 17 标准在2017上半年已经讨论确定。本期我们汇集了编程专家——祁宇(《深入应用 C++ 11》作者,C++ 开源社区 purecpp.org 创始人)的多年经验总结,并详细介绍了 C++ 17 最新标准中值得开发者关注的新特性和基本用法。

本书内容

C++14 实现编译期反射

文/祁宇

本文将通过分析 magic _ get 源码来介绍 magic _ get 实现的关键技术,深入解析实现 pod 类型反射的原理。

pod 类型编译期反射

反射是一种根据元数据来获取类内部信息的机制,通过元数据就可以获取对象的字段和方法等信息。C# 和 Java 的反射机制都是通过获取对象的元数据来实现的。反射可以用于依赖注入、ORM 对象-实体映射、序列化和反序列化等与对象本身信息密切相关的领域。比如 Java 的 Spring 框架,其依赖注入的基础是建立在反射的基础之上的,可以根据元数据获取类型的信息并动态创建对象。ORM 对象-实体之间的映射也是通过反射实现的。Java 和 C# 都是基于中间运行时的语言,中间运行时提供了反射机制,所以反射对于运行时语言来说很容易,但是对于没有中间运行时的语言,要想实现反射是很困难的。

在2016年的 CppCon 技术大会上,Antony Polukhin 做了一个关于 C++ 反射的演讲,他提出了一个实现反射的新思路,即无需使用宏、标记和额外的工具即可实现反射。看起来似乎是一件不可能完成的任务,因为 C++ 是没有反射机制的,无法直接获取对象的元信息。但是 Antony Polukhin 发现对 pod 类型使用 Modern C++ 的模版元技巧可以实现这样的编译期反射。他开源了一个 pod 类型的编译期反射库 magic _ get(https://github.com/apolukhin/magic_get),这个库也准备进入 boost。我们来看看 magic _ get 的使用示例。

#include <boost pfr="" core.hpp="">struct foo {    int some_integer;    char c;};foo f {777, '!'};auto& r1 = boost::pfr::flat_get<0>(f); //通过索引来访问对象foo的第1个字段auto& r2 = boost::pfr::flat_get<1>(f); //通过索引来访问对象foo的第2个字段</boost>

通过这个示例可以看到,magic _ get 确实实现了非侵入式访问 foo 对象的字段,不需要写任何宏、额外的代码以及专门的工具,直接在编译期就可以访问 pod 对象的字段,没有运行期负担,确实有点 magic。

本文将通过分析 magic _ get 源码来介绍 magic _ get 实现的关键技术,深入解析实现 pod 类型反射的原理。

关键技术

实现 pod 类型反射的思路是这样的:先将 pod 类型转换为对应的 tuple 类型,接下来将 pod 类型的值赋给 tuple,然后就可以通过索引去访问 tuple 中的元素了。所以实现 pod 反射的关键就是如何将 pod 类型转换为对应的 tuple 类型和 pod 值赋值给 tuple。

pod 类型转换为 tuple 类型

pod 类型对应的 tuple 类型是什么样的呢?以上面的 foo 为例,foo 对应的 tuple 应该是 tuple<int, char>,即 tuple 中的元素类型和顺序和 pod 类型中的字段完全一一对应。

根据结构体生成一个 tuple 的基本思路是,按顺序将结构体中每个字段的类型萃取出来并保存起来,后面再取出来生成对应的 tuple 类型。然而字段的类型是不同的,C++ 也没有一个能直接保存不同类型的容器,因此需要一个变通的方法,用一个间接的方法来保存萃取出来的字段类型,即将类型转换为一个 size _ t 类型的 id,将这个 id 保存到一个 array<size_t, N> 中,后面根据这个 id 来获取实际的 type 并生成对应的 tuple 类型。

这里需要解决的一个问题是如何实现类型和 id 的相互转换。

type 和 id 在编译期相互转换

先借助一个空的模版类用来保存实际的类型,再借助 C++ 14 的 constexpr 特性,在编译期返回某个类型对应的编译期 id,就可以实现 type 转换为 id 了。具体代码如下:

http://ipad-cms.csdn.net/cms/article/code/3445

上面的代码在编译期将类型 int 和 char 做了一个编码,将类型转换为一个具体的编译期常量,后面就可以根据这些编译期常量来获取对应的具体类型。

编译期根据 id 获取 type 的代码如下:

constexpr auto id_to_type( std::integral_constant<std::size_t, 6=""> ) noexcept { int res{}; return res; }constexpr auto id_to_type( std::integral_constant<std::size_t, 9=""> ) noexcept { char res{}; return res; }</std::size_t,></std::size_t,>

上面的代码中 id _ to _ type 返回的是 id 对应的类型的实例,如果要获取 id 对应的类型还需要通过 decltype 推导出来。magic _ get 通过一个宏将 pod 基本类型都做了一个编码,以实现 type 和 id 在编译期的相互转换。

#define REGISTER_TYPE(Type, Index)                                              \    constexpr std::size_t type_to_id(identity<type>) noexcept { return Index; } \    constexpr auto id_to_type( std::integral_constant<std::size_t, index=""> ) noexcept { Type res{}; return res; }  \// Register all base types here    REGISTER_TYPE(unsigned short    , 1)    REGISTER_TYPE(unsigned int      , 2)    REGISTER_TYPE(unsigned long long , 3)    REGISTER_TYPE(signed char       , 4)    REGISTER_TYPE(short             , 5)    REGISTER_TYPE(int               , 6)    REGISTER_TYPE(long long         , 7)    REGISTER_TYPE(unsigned char     , 8)    REGISTER_TYPE(char              , 9)    REGISTER_TYPE(wchar_t          , 10)    REGISTER_TYPE(long             , 11)    REGISTER_TYPE(unsigned long    , 12)    REGISTER_TYPE(void*            , 13)    REGISTER_TYPE(const void*      , 14)    REGISTER_TYPE(char16_t         , 15)    REGISTER_TYPE(char32_t         , 16)    REGISTER_TYPE(float             , 17)    REGISTER_TYPE(double           , 18)    REGISTER_TYPE(long double      , 19)</std::size_t,></type>

将类型编码之后,保存在哪里以及如何取出来是接着要解决的问题。magic _ get 通过定义一个 array 来保存结构体字段类型 id。

template <class t,="" std::size_t="" n="">   struct array {       typedef T type;       T data[N];       static constexpr std::size_t size() noexcept { return N; }   };</class>

array 中的定长数组 data 中保存字段类型对应的 id,数组下标就是字段在结构体中的位置索引。

萃取 pod 结构体字段

前面介绍了如何实现字段类型的保存和获取,那么这个字段类型是如何从 pod 结构体中萃取出来的呢?具体的做法分为三步:

  • 定义一个保存字段类型 id 的 array;
  • 将 pod 的字段类型转换为对应的 id,按顺序保存到 array 中;
  • 筛除 array 中多余的部分。

下面是具体实现代码:

template <class t="">constexpr auto fields_count_and_type_ids_with_zeros() noexcept {    static_assert(std::is_trivial<t>::value, "Not applyable");    array<std::size_t, sizeof(t)=""> types{};    detect_fields_count_and_type_ids<t>(types.data, std::make_index_sequence<sizeof(t)>{});    return types;}template <class t="">constexpr auto array_of_type_ids() noexcept {    constexpr auto types = fields_count_and_type_ids_with_zeros<t>();    constexpr std::size_t count = count_nonzeros(types);    array<std::size_t, count=""> res{};    for (std::size_t i = 0; i < count; ++i) {        res.data[i] = types.data[i];    }        return res;    }</std::size_t,></t></class></sizeof(t)></t></std::size_t,></t></class>

定义 array 时需要定义一个固定的数组长度,长度为多少合适呢?应按结构体最多的字段数来确定。因为结构体的字段数最多为 sizeof(T),所以 array 的长度设置为 sizeof(T)。array 中的元素全部初始化为0。一般情况下,结构体字段数一般不会超过 array 的长度,那么 array 中就就会出现多余的元素,所以还需要将 array 中多余的字段移除,只保存有效的字段类型 id。具体的做法是计算出 array 中非零的元素有多少,接着再把非零的元素赋给一个新的 array。下面是计算 array 非零元素个数,同样是借助 constexpr 实现编译期计算。

template <class array="">constexpr auto count_nonzeros(Array a) noexcept {    std::size_t count = 0;    for (std::size_t i = 0; i < Array::size() && a.data[i]; ++i)        ++ count;    return count;}</class>

由于字段是按顺序保存到 array 中的,所以在元素值为0时的 count 就是有效的元素个数。接下来我们来看看 detect _ fields _ count _ and _ type _ ids 的实现,这个 constexpr 函数将结构体中的字段类型 id 保存到 array 的 data 中。

detect_fields_count_and_type_ids<t>(types.data, std::make_index_sequence<sizeof(t)>{});</sizeof(t)></t>

detect _ fields _ count _ and _ type _ ids 的第一个参数为定长数组 array <std::size _ t, sizeof(T)> 的 data,第二个参数是一个 std::index _ sequence 整形序列。detect _ fields _ count _ and _ type _ ids 具体实现代码如下:

template <class t,="" std::size_t="" i0,="" std::size_t...="" i="">constexpr auto detect_fields_count_and_type_ids(std::size_t* types, std::index_sequence<i0, i...="">) noexcept-> decltype( type_to_array_of_type_ids<t, i0,="" i...="">(types) ){    return type_to_array_of_type_ids<t, i0,="" i...="">(types);}template <class t,="" std::size_t...="" i="">constexpr T detect_fields_count_and_type_ids(std::size_t* types, std::index_sequence<i...>) noexcept {    return detect_fields_count_and_type_ids<t>(types, std::make_index_sequence<sizeof...(i) -="" 1="">{});}template <class t="">constexpr T detect_fields_count_and_type_ids(std::size_t*, std::index_sequence<>) noexcept {    static_assert(!!sizeof(T), "Failed for unknown reason");    return T{};}</class></sizeof...(i)></t></i...></class></t,></t,></i0,></class>

上面的代码是为了将 index _ sequence 展开为 0,1,2..., sizeof(T) 序列,得到这个序列之后,再调用 type _ to _ array _ of _ type _ ids 函数实现结构体中的字段类型 id 保存到 array 中。

在讲 type _ to _ array _ of _ type _ ids 函数之前我们先看一下辅助结构体 ubiq。保存 pod 字段类型 id 实际上是由辅助结构体 ubiq 实现的,它的实现如下:

template <std::size_t i="">struct ubiq {    std::size_t* ref_;    template <class type="">    constexpr operator Type() const noexcept {        ref_[I] = type_to_id(identity<type>{});        return Type{};    }};</type></class></std::size_t>

这个结构体比较特殊,我们先把它简化一下。

struct ubiq {    template <class type="">    constexpr operator Type() const {        return Type{};    };};</class>

这个结构体的特殊之处在于它可以用来构造任意 pod 类型,比如 int、char、double 等类型。

int i = ubiq{};double d = ubiq{};char c = ubiq{};

因为 ubiq 构造函数所需要的类型由编译器自动推断出来,所以它能构造任意 pod 类型。通过 ubiq 结构体获取了需要构造的类型之后,我们还需要将这个类型转换为 id 按顺序保存到定长数组中。

template <std::size_t i="">struct ubiq {    std::size_t* ref_;    template <class type="">    constexpr operator Type() const noexcept {        ref_[I] = type_to_id(identity<type>{});        return Type{};    }};</type></class></std::size_t>

上面的代码中先将编译器推导出来的类型转换为 id,然后保存到数组下标为 I 的位置。

再回头看 type _ to _ array _ of _ type _ ids 函数。

template <class t,="" std::size_t...="" i="">constexpr auto type_to_array_of_type_ids(std::size_t* types) noexcept -> decltype(T{ ubiq<i>{types}... }) {    return T{ ubiq<i>{types}... };}</i></i></class>

type _ to _ array _ of _ type _ ids 有两个模版参数,第一个 T 是 pod 结构体的类型,第二个 size _ t...为0到 sizeof(T) 的整形序列,函数的入参为 size _ t*,它实际上是 array<std::size_t, sizeof(T)> 的 data,用来保存 pod 字段类型 id。

保存字段类型的关键代码是这一行:T{ ubiq〈I〉{types}... },这里利用了 pod 类型的构造函数,通过 initializer _ list 构造,编译器会将 T 的字段类型推导出来,并借助 ubiq 将字段类型转换为 id 保存到数组中。这个就是 magic _ get 中的 magic。

将 pod 结构体字段 id 保存到数组中之后,接下来就需要将数组中的 id 列表转换为 tuple 了。

pod 字段 id 序列转换为 tuple

pod 字段 id 序列转换为 tuple 的具体做法分为两步:

  • 将 array 中保存的字段类型 id 放入整形序列 std::index _ sequence;
  • 将 index _ sequence 中的类型 id 转换为对应的类型组成 tuple。

下面是具体的实现代码:

template <std::size_t i,="" class="" t,="" std::size_t="" n="">constexpr const T& get(const array<t,n>& a) noexcept {    return a.data[I];}template <class t,="" std::size_t...="" i="">constexpr auto array_of_type_ids_to_index_sequence(std::index_sequence<i...>) noexcept {    constexpr auto a = array_of_type_ids<t>();    return std::index_sequence< get<i>(a)...>{};}</i></t></i...></class></t,n></std::size_t>

get 是返回数组中某个索引位置的元素值,即类型 id,返回的 id 放入 std::index _ sequence 中,接着就是通过 index _ sequence 将 index _ sequence 中的 id 转换为 type,组成一个 tuple。

template <std::size_t... i="">constexpr auto as_tuple_impl(std::index_sequence<i...>) noexcept {    return std::tuple< decltype( id_to_type(std::integral_constant<std::size_t, i="">{}) )... >{};}template <class t="">constexpr auto as_tuple() noexcept {    static_assert(std::is_pod<t>::value, "Not applyable");    constexpr auto res = as_tuple_impl(            array_of_type_ids_to_index_sequence<t>(                    std::make_index_sequence< decltype(array_of_type_ids<t>())::size() >()            )    );    static_assert(sizeof(res) == sizeof(T), "sizes check failed");    static_assert(            std::alignment_of<decltype(res)>::value == std::alignment_of<t>::value,            "alignment check failed"    );    return res;}</t></decltype(res)></t></t></t></class></std::size_t,></i...></std::size_t...>

id _ to _ type 返回的是某个 id 对应的类型实例,所以还需要 decltype 来推导类型。这样我们就可以根据 T 来获取一个 tuple 类型了,接下来是要将 T 的值赋给 tuple,然后就可以根据索引来访问 T 的字段了。

pod 赋值给 tuple

对于 clang 编译器,pod 结构体是可以直接转换为 std::tuple 的,所以对于 clang 编译器来说,到这一步就结束了。

template <std::size_t i,="" class="" t="">decltype(auto) get(const T& val) noexcept {    auto t = reinterpret_cast<const decltype(detail::as_tuple<t="">())*>( std::addressof(val) );    return get<i>(*t);}</i></const></std::size_t>

然而,对于其他编译器,如 msvc 或者 gcc,tuple 的内存并不是连续的,不能直接将 T 转换为 tuple,所以更通用的做法是先做一个内存连续的 tuple,然后就可以将 T 直接转换为 tuple 了。

内存连续的 tuple

下面是实现内存连续的 tuple 代码:

template <std::size_t n,="" class="" t="">struct base_from_member {    T value;};template <class i,="" class="" ...tail="">struct tuple_base;template <std::size_t... i,="" class="" ...tail="">struct tuple_base< std::index_sequence<i...>, Tail... >        : base_from_member<i ,="" tail="">...{    static constexpr std::size_t size_v = sizeof...(I);    constexpr tuple_base() noexcept = default;    constexpr tuple_base(tuple_base&&) noexcept = default;    constexpr tuple_base(const tuple_base&) noexcept = default;    constexpr tuple_base(Tail... v) noexcept            : base_from_member<i, tail="">{ v }...    {}};template <>struct tuple_base<std::index_sequence<> > {    static constexpr std::size_t size_v = 0;};template <class ...values="">struct tuple: tuple_base<        std::make_index_sequence<sizeof...(values)>,        Values...>{    using tuple_base<            std::make_index_sequence<sizeof...(values)>,            Values...    >::tuple_base;};</sizeof...(values)></sizeof...(values)></class></std::index_sequence<></i,></i></i...></std::size_t...></class></std::size_t>

base _ from _ member 用来保存 tuple 元素的索引和值,tuple _ base 派生于 base _ from _ member,自动生成 tuple 中每一个类型的 base _ from _ member,tuple 派生于 tuple _ base 用来简化 tuple _ base 的定义。再给 tuple 增加一个根据索引获取元素的辅助方法。

template <std::size_t n,="" class="" t="">constexpr const T& get_impl(const base_from_member<n, t="">& t) noexcept {    return t.value;}template <std::size_t n,="" class="" ...t="">constexpr decltype(auto) get(const tuple<t...>& t) noexcept {    static_assert(N < tuple<t...>::size_v, "Tuple index out of bounds");    return get_impl<n>(t);}</n></t...></t...></std::size_t></n,></std::size_t>

这样就可以通过 get 就可以获取 tuple 中的元素了。

到此,magic _ get 的核心代码分析完了。由于实际的代码会更复杂,为了让读者能更容易看懂,我选取的是简化版的代码,完整的代码可以参考 GitHub 上的 magicget 或者简化版的代码https://github.com/qicosmos/cosmos/blob/master/podreflection.hpp

总结

magic _ get 实现了对 pod 类型的反射,可以直接通过索引来访问 pod 结构体的字段,而不需要任何额外的宏、标记或工具,确实很 magic。magic _ get 主要是通过 C++11/14 的可变模版参数、constexpr、index _ sequence、pod 构造函数以及很多模版元技巧实现的。那么 magic _ get 可以用来做些什么呢?根据 magic _ get 无需额外的负担和代码就可以实现编译期反射的特点,很适合做 ORM 数据库访问引擎和通用的序列化/反序列化库,我相信还有更多潜力和应用等待我们去发掘。

Modern C++ 的一些看似平淡无奇的特性组合在一起就能产生神奇的魔力,让人不禁赞叹 Modern C++ 蕴藏了无限的可能性与神奇。

C++17 中那些值得关注的特性(上)
C++17 中那些值得关注的特性(中)
C++17 中那些值得关注的特性 (下)

阅读全文: http://gitbook.cn/gitchat/geekbook/5a7a81b85a8e2a1cf2e2a993

2017-12-10 19:21:41 syyyy712 阅读数 7497

C++矩阵转置

 看了很多网山有关矩阵转置的代码,大部分还用了中间变量,本人亲测矩阵转置代码无误,望对广大C++初学者有所帮助!

题目如下:
写一个函数,使给定的一个二维数组(3x3)转置,即行列互换。

Input

一个3×3的矩阵

Output

转置后的矩阵(每两个数字之间均有一个空格)

Sample Input

1 2 3
4 5 6
7 8 9
Sample Output

1 4 7
2 5 8
3 6 9

代码如下:

#include <iostream>
#include <string>
#include <iomanip>
#include <vector>
#include <array>
#include <algorithm>
using namespace std;
//int a[3][3] = { {1,2,3}, {4,5,6}, {7,8,9} };
int a[3][3];
//int temp;
void main() {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cin >> a[i][j];
            cout << " ";
        }
        cout << endl;
    }
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cout << a[j][i]<<" ";   
        }
        cout << endl;
    }
}
先定义一个int 类型的3x3的矩阵a,然后用cin输入,cout输出,输入的时候是按照a[i][j]输入,输出的时候两个for循环还是位置不变,只要将a[i][j]变成a[j][i]输出即可,包含这么多头文件是因为习惯性先把可能用到的头文件尽可能都写进去,同时在输出的for循环内部for循环结束时用了一个cout << endl ,确保最后以矩阵的形式输出。

运行结果:
这里写图片描述

C++ OOP面向对象

阅读数 4257

15个C++项目列表

阅读数 30103

C++常用内置函数

阅读数 2140

C++实现简单二叉树

阅读数 4838

C++实现简单二叉树

博文 来自: qq_1844548689

C++项目经验总结

阅读数 5289

没有更多推荐了,返回首页