青青草原综合久久大伊人导航_色综合久久天天综合_日日噜噜夜夜狠狠久久丁香五月_热久久这里只有精品

MyMSDN

MyMSDN記錄開(kāi)發(fā)新知道

boost::tuple

boost::tuple<derived> tup4;
boost::tuple<base> tup5;
tup5 = tup4;
tup4.get<0>().test();
tup5.get<0>().test(); // 丟失多態(tài)性
derived d; boost::tuple<derived*> tup6(&d); boost::tuple<base*> tup7; tup7 = tup6; tup6.get<0>()->test(); tup7.get<0>()->test(); // 恢復(fù)多態(tài)性(方法1) boost::tuple<derived&> tup8(d); boost::tuple<base&> tup9(tup8);
// tup9 = tup8; 不能使用該方法,因?yàn)闊o(wú)法對(duì)引用賦值。
tup8.get<0>().test(); tup9.get<0>().test(); // 恢復(fù)多態(tài)性(方法2)
/*
 * tuple.cpp
 *
 *  Created on: 2010-3-25
 *      Author: GoCool
 */
#include <stdlib.h>
#include <iostream>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_io.hpp>
#include "../header/baseClass.h"

using namespace std;
class X {
  X();
public:
  X(std::string){}
};
class Y {
  Y(const Y&);
public:
  Y(){}
};
class A {
};
bool operator==(A, A) { std::cout << "All the same to me..."; return true; }
void f(int i);

void cut_off_rule(void);
int main(void){
    // add a new tuple
    boost::tuple<int,double,std::string>   triple(42, 3.14, "My first tuple!");
    int a = triple.get<0>();
    ++a;
    cout << a << endl;
    cout << triple << endl;

    cut_off_rule();

    boost::tuple<int, double> pair = boost::make_tuple(21, 22.5);
    cout << pair << endl;

    cut_off_rule();

    int pair_element_1 = -1;
    double pair_element_2 = -1;
    boost::tie(pair_element_1, pair_element_2) = pair;

    cout << pair_element_1 << "," << pair_element_2 << endl;

    cut_off_rule();

    boost::tuple<int,std::string,derived> tup1(-5,"Tuples");
    boost::tuple<unsigned int,std::string,base> tup2;
    tup2=tup1;
    tup2.get<2>().test();
    std::cout << "Interesting value: " << tup2.get<0>() << '\n';
    const boost::tuple<double,std::string,base> tup3(tup2);
    // Description    Resource    Path    Location    Type
    // assignment of read-only location    tuple.cpp    boost_tuple/src    45    C/C++ Problem
    // tup3.get<0>()=3.14;

    cut_off_rule();

    boost::tuple<X,X,X> obj = boost::tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")); // ok

    cut_off_rule();

    double dNum = 5;
    boost::tuple<double&> numTuple(dNum);               // ok

    // boost::tuple<double&>(dNum+3.14);          // error: cannot initialize
                                    // non-const reference with a temporary

    boost::tuple<const double&>(dNum+3.14);    // ok, but dangerous:
                                    // the element becomes a dangling reference
    cut_off_rule();

    // char arr[2] = {'a', 'b'};
    // boost::tuple<char[2]>(arr); // error, arrays can not be copied
    // boost::tuple<char[2], Y>(arr, Y()); // error, neither arrays nor Y can be copied

    boost::tuple<char[2], Y>();       // ok

    cut_off_rule();

    boost::tuple<void (*)(int)> pFTuple1 = boost::make_tuple(&f);
    pFTuple1.get<0>()(10);

    boost::tuple<void (*)(int)> pFTuple2 = boost::make_tuple(boost::ref(f));
    pFTuple2.get<0>()(20);

    boost::tuple<void (&)(int)> pFTuple3(f);
    pFTuple3.get<0>()(30);

    boost::tuple<boost::tuple<void (&)(int)> > pFTuple4(f);
    pFTuple4.get<0>().get<0>()(40);

    cut_off_rule();

    // boost::tuple<int, char> stdPairToTuple = std::make_pair(1, 'a');

    cut_off_rule();

    boost::tuple<std::string, int, A> t1(std::string("same?"), 2, A());
    boost::tuple<std::string, long> t2(std::string("same?"), 2);
    boost::tuple<std::string, long> t3(std::string("different"), 3);
    // t1 == t2;        // true

    cut_off_rule();

    int i; char c;
    boost::tie(i, c) = std::make_pair(1, 'a');
    cout << i << " " << c << endl;

    cut_off_rule();

    boost::tie(boost::tuples::ignore, c) = std::make_pair(1, 'a');
    cout << c << endl;

    cut_off_rule();

    int myX = -1;
    double myY = -2;
    boost::tuple<int, double> f2(2);
    boost::tie(myX, myY) = f2; // #2
    cout << "myX = " << myX << ", myY = " <<myY << endl;
}
void cut_off_rule(void) {
    cout << "-----------------------------------" << endl;
}

void f(int i) {
    cout << "f(" << i << ")" << endl;
}


tuple是boost庫(kù)中一個(gè)類似標(biāo)準(zhǔn)std::pair庫(kù)庫(kù),但pair只能支持兩種元素,而tuple則可以支持大于兩種的。

更多詳解:http://www.boost.org/doc/libs/1_42_0/libs/tuple/doc/tuple_users_guide.html

以下內(nèi)容直接引自原文:


 

Boost C++ LibrariesBoost C++ Libraries

“...one of the most highly regarded and expertly designed C++ library projects in the world.” — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

C++ 
Boost

The Boost Tuple Library

A tuple (or n-tuple) is a fixed size collection of elements. Pairs, triples, quadruples etc. are tuples. In a programming language, a tuple is a data object containing other objects as elements. These element objects may be of different types.

Tuples are convenient in many circumstances. For instance, tuples make it easy to define functions that return more than one value.

Some programming languages, such as ML, Python and Haskell, have built-in tuple constructs. Unfortunately C++ does not. To compensate for this "deficiency", the Boost Tuple Library implements a tuple construct using templates.

Table of Contents

  1. Using the library
  2. Tuple types
  3. Constructing tuples
  4. Accessing tuple elements
  5. Copy construction and tuple assignment
  6. Relational operators
  7. Tiers
  8. Streaming
  9. Performance
  10. Portability
  11. Acknowledgements
  12. References
More details

Advanced features (describes some metafunctions etc.).

Rationale behind some design/implementation decisions.

Using the library

To use the library, just include:

#include "boost/tuple/tuple.hpp"

Comparison operators can be included with:

#include "boost/tuple/tuple_comparison.hpp"

To use tuple input and output operators,

#include "boost/tuple/tuple_io.hpp"

Both tuple_io.hpp and tuple_comparison.hpp include tuple.hpp.

All definitions are in namespace ::boost::tuples, but the most common names are lifted to namespace ::boost with using declarations. These names are: tuple, make_tuple, tie and get. Further, ref and cref are defined directly under the ::boost namespace.

Tuple types

A tuple type is an instantiation of the tuple template. The template parameters specify the types of the tuple elements. The current version supports tuples with 0-10 elements. If necessary, the upper limit can be increased up to, say, a few dozen elements. The data element can be any C++ type. Note that void and plain function types are valid C++ types, but objects of such types cannot exist. Hence, if a tuple type contains such types as elements, the tuple type can exist, but not an object of that type. There are natural limitations for element types that cannot be copied, or that are not default constructible (see 'Constructing tuples' below).

For example, the following definitions are valid tuple instantiations (A, B and C are some user defined classes):

tuple<int>
tuple<double&, const double&, const double, double*, const double*>
tuple<A, int(*)(char, int), B(A::*)(C&), C>
tuple<std::string, std::pair<A, B> >
tuple<A*, tuple<const A*, const B&, C>, bool, void*>

Constructing tuples

The tuple constructor takes the tuple elements as arguments. For an n-element tuple, the constructor can be invoked with k arguments, where 0 <= k <= n. For example:

tuple<int, double>() 
tuple<int, double>(1)
tuple<int, double>(1, 3.14)

If no initial value for an element is provided, it is default initialized (and hence must be default initializable). For example.

class X {
X();
public:
X(std::string);
};

tuple<X,X,X>() // error: no default constructor for X
tuple<X,X,X>(string("Jaba"), string("Daba"), string("Duu")) // ok

In particular, reference types do not have a default initialization:

tuple<double&>()                // error: reference must be 
// initialized explicitly

double d = 5;
tuple<double&>(d) // ok

tuple<double&>(d+3.14) // error: cannot initialize
// non-const reference with a temporary

tuple<const double&>(d+3.14) // ok, but dangerous:
// the element becomes a dangling reference

Using an initial value for an element that cannot be copied, is a compile time error:

class Y { 
Y(const Y&);
public:
Y();
};

char a[10];

tuple<char[10], Y>(a, Y()); // error, neither arrays nor Y can be copied
tuple<char[10], Y>(); // ok

Note particularly that the following is perfectly ok:

Y y;
tuple<char(&)[10], Y&>(a, y);

It is possible to come up with a tuple type that cannot be constructed. This occurs if an element that cannot be initialized has a lower index than an element that requires initialization. For example: tuple<char[10], int&>.

In sum, the tuple construction is semantically just a group of individual elementary constructions.

The make_tuple function

Tuples can also be constructed using the make_tuple (cf. std::make_pair) helper functions. This makes the construction more convenient, saving the programmer from explicitly specifying the element types:

tuple<int, int, double> add_multiply_divide(int a, int b) {
return make_tuple(a+b, a*b, double(a)/double(b));
}

By default, the element types are deduced to the plain non-reference types. E.g.:

void foo(const A& a, B& b) { 
...
make_tuple(a, b);

The make_tuple invocation results in a tuple of type tuple<A, B>.

Sometimes the plain non-reference type is not desired, e.g. if the element type cannot be copied. Therefore, the programmer can control the type deduction and state that a reference to const or reference to non-const type should be used as the element type instead. This is accomplished with two helper template functions: ref and cref. Any argument can be wrapped with these functions to get the desired type. The mechanism does not compromise const correctness since a const object wrapped with ref results in a tuple element with const reference type (see the fifth example below). For example:

A a; B b; const A ca = a;
make_tuple(cref(a), b); // creates tuple<const A&, B>
make_tuple(ref(a), b); // creates tuple<A&, B>
make_tuple(ref(a), cref(b)); // creates tuple<A&, const B&>
make_tuple(cref(ca)); // creates tuple<const A&>
make_tuple(ref(ca)); // creates tuple<const A&>

Array arguments to make_tuple functions are deduced to reference to const types by default; there is no need to wrap them with cref. For example:

make_tuple("Donald", "Daisy");

This creates an object of type tuple<const char (&)[7], const char (&)[6]> (note that the type of a string literal is an array of const characters, not const char*). However, to get make_tuple to create a tuple with an element of a non-const array type one must use the ref wrapper.

Function pointers are deduced to the plain non-reference type, that is, to plain function pointer. A tuple can also hold a reference to a function, but such a tuple cannot be constructed with make_tuple (a const qualified function type would result, which is illegal):

void f(int i);
...
make_tuple(&f); // tuple<void (*)(int)>
...

volnet:
boost::tuple<void (&)(int)> pFTuple3(f);

pFTuple3.get<0>()(30);

tuple<tuple<void (&)(int)> > a(f) // ok
make_tuple(f); // not ok

Accessing tuple elements

Tuple elements are accessed with the expression:

t.get<N>()

or

get<N>(t)

where t is a tuple object and N is a constant integral expression specifying the index of the element to be accessed. Depending on whether t is const or not, get returns the Nth element as a reference to const or non-const type. The index of the first element is 0 and thus N must be between 0 and k-1, where k is the number of elements in the tuple. Violations of these constraints are detected at compile time. Examples:

double d = 2.7; A a;
tuple<int, double&, const A&> t(1, d, a);
const tuple<int, double&, const A&> ct = t;
...
int i = get<0>(t); i = t.get<0>(); // ok
int j = get<0>(ct); // ok
get<0>(t) = 5; // ok
get<0>(ct) = 5; // error, can't assign to const
...
double e = get<1>(t); // ok
get<1>(t) = 3.14; // ok
get<2>(t) = A(); // error, can't assign to const
A aa = get<3>(t); // error: index out of bounds
...
++get<0>(t); // ok, can be used as any variable

Note! The member get functions are not supported with MS Visual C++ compiler. Further, the compiler has trouble with finding the non-member get functions without an explicit namespace qualifier. Hence, all get calls should be qualified as: tuples::get<N>(a_tuple) when writing code that should compile with MSVC++ 6.0.

Copy construction and tuple assignment

A tuple can be copy constructed from another tuple, provided that the element types are element-wise copy constructible. Analogously, a tuple can be assigned to another tuple, provided that the element types are element-wise assignable. For example:

class A {};
class B : public A {};
struct C { C(); C(const B&); };
struct D { operator C() const; };
tuple<char, B*, B, D> t;
...
tuple<int, A*, C, C> a(t); // ok
a = t; // ok

In both cases, the conversions performed are: char -> int, B* -> A* (derived class pointer to base class pointer), B -> C (a user defined conversion) and D -> C (a user defined conversion).

Note that assignment is also defined from std::pair types:

tuple<float, int> a = std::make_pair(1, 'a');

volnet:(Eclipse with MinGW g++
conversion from `std::pair<int, char>' to non-scalar type `boost::tuples::tuple<float, int, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type>' requested

Relational operators

Tuples reduce the operators ==, !=, <, >, <= and >= to the corresponding elementary operators. This means, that if any of these operators is defined between all elements of two tuples, then the same operator is defined between the tuples as well. The equality operators for two tuples a and b are defined as:

  • a == b iff for each i: ai == bi
  • a != b iff exists i: ai != bi

The operators <, >, <= and >= implement a lexicographical ordering.

Note that an attempt to compare two tuples of different lengths results in a compile time error. Also, the comparison operators are "short-circuited": elementary comparisons start from the first elements and are performed only until the result is clear.

Examples:

tuple<std::string, int, A> t1(std::string("same?"), 2, A());
tuple<std::string, long, A> t2(std::string("same?"), 2, A());
tuple<std::string, long, A> t3(std::string("different"), 3, A());

bool operator==(A, A) { std::cout << "All the same to me..."; return true; }

t1 == t2; // true
t1 == t3; // false, does not print "All the..."

Tiers

Tiers are tuples, where all elements are of non-const reference types. They are constructed with a call to the tie function template (cf. make_tuple):

int i; char c; double d; 
...
tie(i, c, a);

The above tie function creates a tuple of type tuple<int&, char&, double&>. The same result could be achieved with the call make_tuple(ref(i), ref(c), ref(a)).

A tuple that contains non-const references as elements can be used to 'unpack' another tuple into variables. E.g.:

int i; char c; double d; 
tie(i, c, d) = make_tuple(1,'a', 5.5);
std::cout << i << " " << c << " " << d;

This code prints 1 a 5.5 to the standard output stream. A tuple unpacking operation like this is found for example in ML and Python. It is convenient when calling functions which return tuples.

The tying mechanism works with std::pair templates as well:

int i; char c;
tie(i, c) = std::make_pair(1, 'a');
Ignore

There is also an object called ignore which allows you to ignore an element assigned by a tuple. The idea is that a function may return a tuple, only part of which you are interested in. For example (note, that ignore is under the tuples subnamespace):

char c;
tie(tuples::ignore, c) = std::make_pair(1, 'a');

Streaming

The global operator<< has been overloaded for std::ostream such that tuples are output by recursively calling operator<< for each element.

Analogously, the global operator>> has been overloaded to extract tuples from std::istream by recursively calling operator>> for each element.

The default delimiter between the elements is space, and the tuple is enclosed in parenthesis. For Example:

tuple<float, int, std::string> a(1.0f,  2, std::string("Howdy folks!");

cout << a;

outputs the tuple as: (1.0 2 Howdy folks!)

The library defines three manipulators for changing the default behavior:

  • set_open(char) defines the character that is output before the first element.
  • set_close(char) defines the character that is output after the last element.
  • set_delimiter(char) defines the delimiter character between elements.

Note, that these manipulators are defined in the tuples subnamespace. For example:

cout << tuples::set_open('[') << tuples::set_close(']') << tuples::set_delimiter(',') << a; 

outputs the same tuple a as: [1.0,2,Howdy folks!]

The same manipulators work with operator>> and istream as well. Suppose the cin stream contains the following data:

(1 2 3) [4:5]

The code:

tuple<int, int, int> i;
tuple<int, int> j;

cin >> i;
cin >> tuples::set_open('[') >> tuples::set_close(']') >> tuples::set_delimiter(':');
cin >> j;

reads the data into the tuples i and j.

Note that extracting tuples with std::string or C-style string elements does not generally work, since the streamed tuple representation may not be unambiguously parseable.

Performance

All tuple access and construction functions are small inlined one-liners. Therefore, a decent compiler can eliminate any extra cost of using tuples compared to using hand-written tuple like classes. Particularly, with a decent compiler there is no performance difference between this code:

class hand_made_tuple { 
A a; B b; C c;
public:
hand_made_tuple(const A& aa, const B& bb, const C& cc)
: a(aa), b(bb), c(cc) {};
A& getA() { return a; };
B& getB() { return b; };
C& getC() { return c; };
};

hand_made_tuple hmt(A(), B(), C());
hmt.getA(); hmt.getB(); hmt.getC();

and this code:

tuple<A, B, C> t(A(), B(), C());
t.get<0>(); t.get<1>(); t.get<2>();

Note, that there are widely used compilers (e.g. bcc 5.5.1) which fail to optimize this kind of tuple usage.

Depending on the optimizing ability of the compiler, the tier mechanism may have a small performance penalty compared to using non-const reference parameters as a mechanism for returning multiple values from a function. For example, suppose that the following functions f1 and f2 have equivalent functionalities:

void f1(int&, double&);
tuple<int, double> f2();

Then, the call #1 may be slightly faster than #2 in the code below:

int i; double d;
...
f1(i,d); // #1
tie(i,d) = f2(); // #2

volnet:
int myX = -1;
double myY = -2;
boost::tuple<int, double> f2(2);
boost::tie(myX, myY) = f2; // #2
cout << "myX = " << myX << ", myY = " <<myY << endl;

See [1, 2] for more in-depth discussions about efficiency.

Effect on Compile Time

Compiling tuples can be slow due to the excessive amount of template instantiations. Depending on the compiler and the tuple length, it may be more than 10 times slower to compile a tuple construct, compared to compiling an equivalent explicitly written class, such as the hand_made_tuple class above. However, as a realistic program is likely to contain a lot of code in addition to tuple definitions, the difference is probably unnoticeable. Compile time increases between 5 and 10 percent were measured for programs which used tuples very frequently. With the same test programs, memory consumption of compiling increased between 22% to 27%. See [1, 2] for details.

Portability

The library code is(?) standard C++ and thus the library works with a standard conforming compiler. Below is a list of compilers and known problems with each compiler:

Compiler
Problems

gcc 2.95
-

edg 2.44
-

Borland 5.5
Can't use function pointers or member pointers as tuple elements

Metrowerks 6.2
Can't use ref and cref wrappers

MS Visual C++
No reference elements (tie still works). Can't use ref and cref wrappers

Acknowledgements

Gary Powell has been an indispensable helping hand. In particular, stream manipulators for tuples were his idea. Doug Gregor came up with a working version for MSVC, David Abrahams found a way to get rid of most of the restrictions for compilers not supporting partial specialization. Thanks to Jeremy Siek, William Kempf and Jens Maurer for their help and suggestions. The comments by Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, David Abrahams and Hartmut Kaiser helped to improve the library. The idea for the tie mechanism came from an old usenet article by Ian McCulloch, where he proposed something similar for std::pairs.

References

[1] J?rvi J.: Tuples and multiple return values in C++, TUCS Technical Report No 249, 1999.

[2] J?rvi J.: ML-Style Tuple Assignment in Standard C++ - Extending the Multiple Return Value Formalism, TUCS Technical Report No 267, 1999.

[3] J?rvi J.:Tuple Types and Multiple Return Values, C/C++ Users Journal, August 2001.


Last modified 2003-09-07

? Copyright Jaakko J?rvi 2001. Permission to copy, use, modify, sell and distribute this software and its documentation is granted provided this copyright notice appears in all copies. This software and its documentation is provided "as is" without express or implied warranty, and with no claim as to its suitability for any purpose.



 

posted on 2010-03-25 17:46 volnet 閱讀(1722) 評(píng)論(0)  編輯 收藏 引用 所屬分類: C/C++

特殊功能
 
青青草原综合久久大伊人导航_色综合久久天天综合_日日噜噜夜夜狠狠久久丁香五月_热久久这里只有精品
  • <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>
            欧美激情综合网| 亚洲第一福利视频| 午夜国产不卡在线观看视频| 日韩视频中文字幕| 欧美一区二区三区四区在线观看| 欧美在线欧美在线| 狠狠色综合一区二区| 欧美激情第9页| 欧美日韩在线播放一区| 尤物精品国产第一福利三区| 美女精品在线观看| 欧美日韩第一区| 欧美一区=区| 美女视频黄免费的久久| 亚洲一区免费观看| 久久精品国产第一区二区三区| 欧美三级电影精品| 久久精品视频在线| 欧美成人激情视频免费观看| 亚洲一区二区少妇| 久久久高清一区二区三区| 99re热这里只有精品视频| 亚洲一区国产视频| 亚洲黑丝在线| 久久精品一区二区三区不卡| 免费亚洲视频| 性欧美18~19sex高清播放| 久久综合激情| 午夜精品一区二区在线观看| 免费看的黄色欧美网站| 久久精品国产v日韩v亚洲| 欧美日韩国产91| 猛干欧美女孩| 国产欧美日韩综合| 亚洲久久在线| 在线看视频不卡| 午夜精彩视频在线观看不卡| 在线视频精品一区| 亚洲精品综合| 在线观看国产精品淫| 亚洲影院色无极综合| 一区二区三区不卡视频在线观看 | 欧美一级播放| 欧美激情视频一区二区三区免费| 亚洲国产日韩欧美综合久久| 亚洲欧美综合v| 韩国成人理伦片免费播放| 在线亚洲自拍| 国产精品午夜电影| 99爱精品视频| avtt综合网| 欧美激情精品久久久久久黑人| 亚洲狼人精品一区二区三区| 久久久久国产精品www| 欧美亚洲在线播放| 欧美三日本三级少妇三2023 | 欧美性猛交xxxx乱大交蜜桃| 亚洲国产欧洲综合997久久| 在线看片日韩| 久久综合久久美利坚合众国| 免费欧美电影| 亚洲国产精品传媒在线观看| 日韩一二在线观看| 亚洲美女在线看| 欧美激情亚洲自拍| 欧美一区二区免费观在线| 国产精品久久久久久久久久久久| 亚洲日本中文字幕免费在线不卡| 国产最新精品精品你懂的| 亚洲视频一二区| 日韩一二三区视频| 欧美日韩亚洲一区| 99精品免费网| 亚洲欧美精品| 国产日韩欧美一区二区三区四区| 欧美波霸影院| 亚洲精品中文字幕在线| 欧美日韩一区二| 亚洲一区二区视频| 久久久一本精品99久久精品66| 欧美高清在线| 亚洲日韩视频| 激情六月婷婷久久| 久久影视精品| 亚洲毛片一区| 久久久国产精品一区二区中文| 欧美日韩精品免费看| 亚洲天堂免费观看| 久久久久se| 亚洲裸体在线观看| 国产精品一二三视频| 久久九九热re6这里有精品| 亚洲欧美国产制服动漫| 国内精品久久久久影院 日本资源| 夜夜嗨av一区二区三区| 久久国产直播| 夜夜嗨av色一区二区不卡| 欧美在线视频在线播放完整版免费观看 | 久久久.com| 亚洲精品自在在线观看| 久久精品国产亚洲一区二区三区| 欧美日韩在线观看一区二区| 性高湖久久久久久久久| 亚洲激情在线观看| 午夜精品久久久久久久久久久久| 久久影院午夜片一区| 99视频精品全部免费在线| 久久午夜激情| 亚洲欧美日韩精品久久久| 美女福利精品视频| 日韩一本二本av| 免费观看在线综合色| 午夜免费在线观看精品视频| 最新69国产成人精品视频免费 | 麻豆成人小视频| 亚洲香蕉视频| 91久久精品国产| 国内免费精品永久在线视频| 欧美一乱一性一交一视频| 日韩视频在线一区二区| 欧美大片国产精品| 久久中文在线| 亚洲韩日在线| 欧美成人资源网| 久久久欧美一区二区| 香蕉久久久久久久av网站| 99成人精品| 亚洲免费av观看| 亚洲电影网站| 欧美激情一区二区在线| 免费在线欧美黄色| 久久综合伊人77777尤物| 久久精品国产成人| 欧美在线视频一区二区三区| 午夜精品理论片| 亚洲一二三区精品| 亚洲在线网站| 亚洲欧美中文日韩在线| 午夜精品福利视频| 小处雏高清一区二区三区| 亚洲欧美成人一区二区在线电影| 国产精品v日韩精品v欧美精品网站| 亚洲欧美一区在线| 性8sex亚洲区入口| 亚洲女性裸体视频| 中日韩高清电影网| 亚洲一区二区不卡免费| 亚洲一区二区三区免费视频| 国内外成人免费激情在线视频网站 | 玖玖玖国产精品| 老司机一区二区| 欧美二区在线看| 亚洲日本aⅴ片在线观看香蕉| 亚洲免费在线看| 欧美一区激情| 久久综合导航| 亚洲人成毛片在线播放| 99在线视频精品| 亚洲尤物在线视频观看| 久久久久久网| 欧美久久影院| 国产精品国产| 国产专区欧美精品| 91久久在线| 亚洲一区三区在线观看| 久久国产精品免费一区| 日韩亚洲欧美成人| 一区二区高清视频| 欧美一级一区| 欧美大片专区| 一区二区三区久久| 免费观看不卡av| 榴莲视频成人在线观看| 亚洲青色在线| 欧美在线国产精品| 欧美人成在线视频| 久久精品导航| 欧美另类videos死尸| 国产一区导航| 这里只有视频精品| 久久夜色精品国产亚洲aⅴ | 欧美日韩在线观看一区二区| 国产日韩在线播放| 日韩视频免费大全中文字幕| 久久精品视频一| 日韩视频中午一区| 久久综合久久久久88| 国产精品一区二区三区四区| 欧美网站在线| 亚洲国产日韩欧美在线图片| 欧美在线视频免费播放| 日韩亚洲一区在线播放| 久热国产精品| 国产亚洲欧美一区二区| 中文国产成人精品久久一| 欧美激情久久久| 久久久精品2019中文字幕神马| 久久亚洲欧美| 免费在线观看日韩欧美| 免费观看不卡av|