精华内容
下载资源
问答
  • 对于指针类型vector* >,在使用push_back()存入数据的操作时可能出现改变 vector 中前面存在的数据,在使用指针类型vector 时要注意这个问题。列举一个例子来说明这个问题,使用的 vector 类型为 int*:typedef...

    对于指针类型的vector<DataType* >,在使用push_back()存入数据的操作时可能出现改变 vector 中前面存在的数据,在使用指针类型的 vector 时要注意这个问题。

    列举一个例子来说明这个问题,使用的 vector 类型为 int*:

    typedef std::vector<int*> ShitVector_pint; 

    下面的代码做的操作是向这个 examVector 这个 vector 中存入两个指向 int 类型的指针,并输出所指向的两个整数。

    int _tmain(int argc, _TCHAR* argv[])
    {
        ShitVector_pint examVector;
    
        int p_intnum_1 = 250;
        int* p_int_1;
        p_int_1 = &p_intnum_1;
        examVector.push_back(p_int_1);
        std::cout << *examVector[0] << std::endl;
    
        int p_intnum_2 = 47;
    //  p_intnum_1 = 74;    // p_intnum_1 的改变会引起 examVector 的实时变化
        p_int_1 = &p_intnum_2;
        examVector.push_back(p_int_1);  // 一旦 p_intnum_1 重新赋值,examVector也更新了
        std::cout << *examVector[0] << " " << *examVector[1] << std::endl;
    
        system("pause");
        return 0;
    }

    此时的输出结果是 *examVector[0] = 250; *examVector[1] = 47
    这里写图片描述
    但如果对 p_intnum_1 重新赋值,*examVector[0] 中的值也会随着一起改变。如果再加入一行代码p_intnum_1 = 74; 输出结果就成了*examVector[0] = 74; *examVector[1] = 47
    这里写图片描述
    之前的值 250 变成了新的值 74。

    出现这个问题的原因在于vector<int*>存入的是 int 类型变量的地址,examVector[0] 中是 p_int_1 的地址, 当 p_int_1 变化时 examVector[0] 也会随着发生变化。这种情况的出现对简单的变量类型像 int 还好理解,对一些复杂的变量类型就不太容易找出什么原因,比如一个结构体类型:

    void CBlockFun::AssignvOrhCoordint(CDC* pDC)
    {
        struct BlockDataStruct
        {
            double x, y, z;     // 块的实际坐标
            int DirctnD2U,      // Down2Up, 0 || 1
                DirctnU2D,     // Up2Down, 0 || -1
                DirctnR2L,      // Right2Left, 0 || -1
                DirctnL2R;      // Left2Right, 0 || 1
            CPoint Circord;     // 圆圈坐标
            CPoint Squcord;     // 方块坐标
            int CirNum, SquNum;
        };
        std::vector< BlockDataStruct* > vOrhCoordint;
    
        BlockDataStruct* pBlockStrt = new BlockDataStruct;
    
        pBlockStrt->DirctnD2U = 1;
        pBlockStrt->DirctnU2D = 0;
        pBlockStrt->DirctnL2R = 0;
        pBlockStrt->DirctnR2L = 0;
        pBlockStrt->Circord.x = InitialCordx;
        pBlockStrt->Circord.y = InitialCordy;
        pBlockStrt->Squcord.x = pBlockStrt->Circord.x + 
            LENGTHARROW * 2 * (pBlockStrt->DirctnL2R + pBlockStrt->DirctnR2L);
        pBlockStrt->Squcord.y = pBlockStrt->Circord.y + 
            LENGTHARROW * 2 * (pBlockStrt->DirctnD2U + pBlockStrt->DirctnU2D);
        pBlockStrt->CirNum = iInitlCirNum;
        pBlockStrt->SquNum = iInitlSquNum;
    
        vOrhCoordint.push_back(pBlockStrt);
    
    
    / *
        // 向 vOrhCoordint 中再继续放入元素
        // !!! pBlockStrt 改变后,vOrhCoordint 也跟着变了
    
        pBlockStrt->Circord.x = vOrhCoordint[i-1]->Squcord.x +
            (pBlockStrt->DirctnL2R + pBlockStrt->DirctnR2L) * LENGTHARROW * 2;
        pBlockStrt->Circord.y = vOrhCoordint[i-1]->Squcord.y + 
            (pBlockStrt->DirctnD2U + pBlockStrt->DirctnU2D) * LENGTHARROW * 2;
    
        pBlockStrt->Squcord.x = pBlockStrt->Circord.x + 
            LENGTHARROW * 2 * (pBlockStrt->DirctnL2R + pBlockStrt->DirctnR2L);
        pBlockStrt->Squcord.y = pBlockStrt->Circord.y + 
            LENGTHARROW * 2 * (pBlockStrt->DirctnD2U + pBlockStrt->DirctnU2D);
    
        pBlockStrt->CirNum = vOrhCoordint[i-1]->CirNum + 1;
        pBlockStrt->SquNum = vOrhCoordint[i-1]->SquNum + 1;
    
        vOrhCoordint.push_back(pBlockStrt);
    
        // 删除 pBlockStrtvOrhCoordint 中的值也没了
         delete pBlockStrt;* /
    }

    pBlockStrt 是指向结构体类型的指针,向 vOrhCoordint 中添加值的时候通过 pBlockStrt 来完成的,在第一次操作vOrhCoordint.push_back(pBlockStrt) 后,对 pBlockStrt 重新赋值就会使得 vOrthCoordint 存入的内容也跟着改变,这个错误问题在复杂些的情况不太容易发现。

    问题的总结:
    1. 对指针类型的 vector 添加元素的操作注意 push_back() 中的指针内容变化,值的传递会影响 vector 中的内容。
    2. 指针的值传递没有理解的太好,还是要多注意下指针的操作。
    3. 对 vector 的使用要稍微熟悉些了,这问题解决虽然花了一整天,但还开始会调试了,算是有收获。
    4. 2、3条是废话。

    展开全文
  • ////定义一个三维vector向量,这么定义有什么不对吗? void setVecInterference(); } A.cpp文件: void A::setVecInterference() { VecInterference[1][2][3] = 5;////VecInterference下面...
  • 比如有一个指针: ``` std::vector<std::vector<std::string>> *values = new std::vector<std::vector<std::string>>(); ``` values 内添加了很多 std::vector。 最后释放 values 时,需要释放 values...
  • vector 指针类型元素的释放

    千次阅读 2010-08-16 22:21:00
    做项目的时候刚开始接触到stl的vector。其中用vector类型管理指针类型的元素。Code: #include "stdafx.h" #include #include #include #include ///////////////////////////

    做项目的时候刚开始接触到stl的vector。其中用vector类型管理指针类型的元素。

    Code:
    1. #include "stdafx.h"   
    2. #include <stdlib.h>   
    3. #include <stdio.h>   
    4. #include <iostream>   
    5.   
    6. #include <vector>   
    7. //   
    8. //初始化    
    9. bool init_Vec(std::vector<char *> &vecTest,unsigned int nElem)   
    10. {   
    11.  //判断初始时是否为空   
    12.  char i=0;   
    13.  char* ch="i will be success!";   
    14.  if (!vecTest.empty())   
    15.  {//初始不为空 清空   
    16.         std::vector<char *>::iterator iter=vecTest.begin();   
    17.   for (;iter<vecTest.end();iter++)   
    18.   {   
    19.    char *nc=*iter;   
    20.    delete nc;   
    21.   }   
    22.   vecTest.clear();   
    23.  }   
    24.  if (0==nElem)   
    25.  {   
    26.         goto init_Vec_end;   
    27.  }   
    28.  //初始化   
    29.    for (i=0;i<(char)nElem;i++)   
    30.    {   
    31.     char* pchar=new char;   
    32.     //申请成功   
    33.     if (pchar)   
    34.     {   
    35.      pchar=&ch[i];   
    36.         vecTest.push_back(pchar);   
    37.     }   
    38.     else  
    39.     {   
    40.          delete pchar;   
    41.    goto init_Vec_break;   
    42.     }     
    43.    }   
    44.    //正常初始化完成   
    45.    return true;   
    46. init_Vec_break:   
    47.     //初始化失败 释放已有资源   
    48.    {   
    49.     std::vector<char *>::iterator iter=vecTest.begin();   
    50.     for (;iter<vecTest.end();iter++)   
    51.     {   
    52.      char *nc=*iter;   
    53.      delete nc;   
    54.     }   
    55.     vecTest.clear();   
    56.    }   
    57. init_Vec_end:   
    58.    return false;   
    59. }   
    60. //   
    61. //打印   
    62. void Printf_Value(std::vector<char *> vecTest)   
    63. {   
    64.     std::vector<char *>::iterator iter=vecTest.begin();   
    65.  for(;iter!=vecTest.end();iter++)   
    66.  {   
    67.         char *nc=*iter;   
    68.   printf("%c,%d /n",*nc,*nc);   
    69.  }   
    70. }   
    71.   
    72. //   
    73. //释放资源   
    74. void Clear_vec(std::vector<char *> vecTest)   
    75. {   
    76.     if (!vecTest.empty())   
    77.  {   
    78.         std::vector<char *>::iterator iter=vecTest.begin();   
    79.   for (;iter<vecTest.end();iter++)   
    80.   {   
    81.    char* nc=*iter;   
    82.    delete nc;   
    83.   }   
    84.   vecTest.clear();   
    85.  }   
    86. }   
    87.   
    88. int main(int argc, char* argv[])   
    89. {   
    90.  //声明变量   
    91.  std::vector<char *> m_vecTest;   
    92.  if (!init_Vec(m_vecTest,15))   
    93.  {   
    94.   printf("{ init_Vec }  failed! /n");   
    95.   goto End_Main;   
    96.  }   
    97.     
    98.  Printf_Value(m_vecTest);   
    99.  Clear_vec(m_vecTest);   
    100. End_Main:   
    101.  printf("Hello World!/n");   
    102.  return 0;   
    103. }   
    104.   

    //在 vc 6.0 中编译通过 

    展开全文
  • 第四版Exercise Section 5.6 的5.1.6 有一道题是这样的:编写程序定义一个vector对象,其每个元素都是指向string类型指针,读取vector对象并输出每个string类型的值以及其长度。 1 // 2_3.cpp : 定义控制台...

    <<C++ Primer>> 第四版Exercise Section 5.6 的5.1.6 有一道题是这样的:编写程序定义一个vector对象,其每个元素都是指向string类型的指针,读取vector对象并输出每个string类型的值以及其长度。

     1 // 2_3.cpp : 定义控制台应用程序的入口点。
     2 //
     3 
     4 #include "stdafx.h"
     5 #include <iostream>
     6 #include <string>
     7 #include <vector>
     8 #include <ctime>
     9 
    10 using namespace std;
    11 
    12 int main()
    13 {
    14     vector<string*> vect;
    15     string str = "hello";
    16     string str1 = "world";
    17     vect.push_back(&str);
    18     vect.push_back(&str1);
    19 
    20     for (vector<string*>::iterator begin = vect.begin(); begin != vect.end(); ++begin)
    21     {
    22         cout << *(*begin) << endl;
    23         cout << (*begin)->length() << endl;
    24     }
    25 
    26     return 0;
    27 }

     

    其实这里想要考查的是,通过指针获取对象的成员函数可以使用-> 操作符。

    转载于:https://www.cnblogs.com/lucy-lizhi/p/6483197.html

    展开全文
  • Python 定义一个完整的 vector

    千次阅读 2019-04-19 12:27:44
    版: # BEGIN VECTOR_V1 from array import array import reprlib import math class Vector: typecode = 'd' def __init__(self, components): self._components = array(self.typecode, co...

    第一版:
     

    # BEGIN VECTOR_V1
    from array import array
    import reprlib
    import math
    
    
    class Vector:
        typecode = 'd'
    
        def __init__(self, components):
            self._components = array(self.typecode, components)  # <1>
    
        def __iter__(self):
            return iter(self._components)  # <2>
    
        def __repr__(self):
            components = reprlib.repr(self._components)  # <3>
            components = components[components.find('['):-1]  # <4>
            return 'Vector({})'.format(components)
    
        def __str__(self):
            return str(tuple(self))
    
        def __bytes__(self):
            return (bytes([ord(self.typecode)]) +
                    bytes(self._components))  # <5>
    
        def __eq__(self, other):
            return tuple(self) == tuple(other)
    
        def __abs__(self):
            return math.sqrt(sum(x * x for x in self))  # <6>
    
        def __bool__(self):
            return bool(abs(self))
    
        @classmethod
        def frombytes(cls, octets):
            typecode = chr(octets[0])
            memv = memoryview(octets[1:]).cast(typecode)
            return cls(memv)  # <7>
    # END VECTOR_V1

    第二版: 可切片的序列

    from array import array
    import reprlib
    import math
    import numbers
    
    
    class Vector:
        typecode = 'd'
    
        def __init__(self, components):
            self._components = array(self.typecode, components)
    
        def __iter__(self):
            return iter(self._components)
    
        def __repr__(self):
            components = reprlib.repr(self._components)
            components = components[components.find('['):-1]
            return 'Vector({})'.format(components)
    
        def __str__(self):
            return str(tuple(self))
    
        def __bytes__(self):
            return (bytes([ord(self.typecode)]) +
                    bytes(self._components))
    
        def __eq__(self, other):
            return tuple(self) == tuple(other)
    
        def __abs__(self):
            return math.sqrt(sum(x * x for x in self))
    
        def __bool__(self):
            return bool(abs(self))
    
    # BEGIN VECTOR_V2
        def __len__(self):
            return len(self._components)
    
        def __getitem__(self, index):
            cls = type(self)  # <1>
            if isinstance(index, slice):  # <2>
                return cls(self._components[index])  # <3>
            elif isinstance(index, numbers.Integral):  # <4>
                return self._components[index]  # <5>
            else:
                msg = '{cls.__name__} indices must be integers'
                raise TypeError(msg.format(cls=cls))  # <6>
    # END VECTOR_V2
    
        @classmethod
        def frombytes(cls, octets):
            typecode = chr(octets[0])
            memv = memoryview(octets[1:]).cast(typecode)
            return cls(memv)
    

    V2中最大的变化在于实现 __len__ 和 __getitem__ 从而实现了切片功能,这两个方法也是 vector 表现为序列所必需的

    若使用 [1:4],返回的是 slice ,slice 是内置的类型,通过审查 slice ,发现它有 start,stop和step 数据属性,以及 indices 方法。indices 中,给定长度为 len 的序列,计算 s 标识的扩展切片的起始和结束索引,以及步幅,超过边界的索引会被截掉。

     Vector 第三版: 动态存取属性

    from array import array
    import reprlib
    import math
    import numbers
    
    
    class Vector:
        typecode = 'd'
    
        def __init__(self, components):
            self._components = array(self.typecode, components)
    
        def __iter__(self):
            return iter(self._components)
    
        def __repr__(self):
            components = reprlib.repr(self._components)
            components = components[components.find('['):-1]
            return 'Vector({})'.format(components)
    
        def __str__(self):
            return str(tuple(self))
    
        def __bytes__(self):
            return (bytes([ord(self.typecode)]) +
                    bytes(self._components))
    
        def __eq__(self, other):
            return tuple(self) == tuple(other)
    
        def __abs__(self):
            return math.sqrt(sum(x * x for x in self))
    
        def __bool__(self):
            return bool(abs(self))
    
        def __len__(self):
            return len(self._components)
    
        def __getitem__(self, index):
            cls = type(self)
            if isinstance(index, slice):
                return cls(self._components[index])
            elif isinstance(index, numbers.Integral):
                return self._components[index]
            else:
                msg = '{.__name__} indices must be integers'
                raise TypeError(msg.format(cls))
    
    # BEGIN VECTOR_V3_GETATTR
        shortcut_names = 'xyzt'
    
        def __getattr__(self, name):
            cls = type(self)  # <1>
            if len(name) == 1:  # <2>
                pos = cls.shortcut_names.find(name)  # <3>
                if 0 <= pos < len(self._components):  # <4>
                    return self._components[pos]
            msg = '{.__name__!r} object has no attribute {!r}'  # <5>
            raise AttributeError(msg.format(cls, name))
    # END VECTOR_V3_GETATTR
    
    # BEGIN VECTOR_V3_SETATTR
        def __setattr__(self, name, value):
            cls = type(self)
            if len(name) == 1:  # <1>
                if name in cls.shortcut_names:  # <2>
                    error = 'readonly attribute {attr_name!r}'
                elif name.islower():  # <3>
                    error = "can't set attributes 'a' to 'z' in {cls_name!r}"
                else:
                    error = ''  # <4>
                if error:  # <5>
                    msg = error.format(cls_name=cls.__name__, attr_name=name)
                    raise AttributeError(msg)
            super().__setattr__(name, value)  # <6>
    
    # END VECTOR_V3_SETATTR
    
        @classmethod
        def frombytes(cls, octets):
            typecode = chr(octets[0])
            memv = memoryview(octets[1:]).cast(typecode)
            return cls(memv)
    

    __getattr__ 和 __setattr__ ,前者是为了获取 vector 分量,后者是对已有分量的保护,v.x 不可以直接赋值,因为 x已经成为v的属性了,v.x 的值改变了,但是v的值未改变。

    Vector 第四版: 散列和快速等值测试

    from array import array
    import reprlib
    import math
    import numbers
    import functools
    import operator
    
    
    class Vector:
        typecode = 'd'
    
        def __init__(self, components):
            self._components = array(self.typecode, components)
    
        def __iter__(self):
            return iter(self._components)
    
        def __repr__(self):
            components = reprlib.repr(self._components)
            components = components[components.find('['):-1]
            return 'Vector({})'.format(components)
    
        def __str__(self):
            return str(tuple(self))
    
        def __bytes__(self):
            return (bytes([ord(self.typecode)]) +
                    bytes(self._components))
    
        def __eq__(self, other):
            return (len(self) == len(other) and
                    all(a == b for a, b in zip(self, other)))
    
        def __hash__(self):
            hashes = (hash(x) for x in self)
            return functools.reduce(operator.xor, hashes, 0)
    
        def __abs__(self):
            return math.sqrt(sum(x * x for x in self))
    
        def __bool__(self):
            return bool(abs(self))
    
        def __len__(self):
            return len(self._components)
    
        def __getitem__(self, index):
            cls = type(self)
            if isinstance(index, slice):
                return cls(self._components[index])
            elif isinstance(index, numbers.Integral):
                return self._components[index]
            else:
                msg = '{cls.__name__} indices must be integers'
                raise TypeError(msg.format(cls=cls))
    
        shortcut_names = 'xyzt'
    
        def __getattr__(self, name):
            cls = type(self)
            if len(name) == 1:
                pos = cls.shortcut_names.find(name)
                if 0 <= pos < len(self._components):
                    return self._components[pos]
            msg = '{.__name__!r} object has no attribute {!r}'
            raise AttributeError(msg.format(cls, name))
    
        @classmethod
        def frombytes(cls, octets):
            typecode = chr(octets[0])
            memv = memoryview(octets[1:]).cast(typecode)
            return cls(memv)
    

    第五版: 格式化

    # BEGIN VECTOR_V5
    """
    A multi-dimensional ``Vector`` class, take 5
    
    A ``Vector`` is built from an iterable of numbers::
    
        >>> Vector([3.1, 4.2])
        Vector([3.1, 4.2])
        >>> Vector((3, 4, 5))
        Vector([3.0, 4.0, 5.0])
        >>> Vector(range(10))
        Vector([0.0, 1.0, 2.0, 3.0, 4.0, ...])
    
    
    Tests with 2-dimensions (same results as ``vector2d_v1.py``)::
    
        >>> v1 = Vector([3, 4])
        >>> x, y = v1
        >>> x, y
        (3.0, 4.0)
        >>> v1
        Vector([3.0, 4.0])
        >>> v1_clone = eval(repr(v1))
        >>> v1 == v1_clone
        True
        >>> print(v1)
        (3.0, 4.0)
        >>> octets = bytes(v1)
        >>> octets
        b'd\\x00\\x00\\x00\\x00\\x00\\x00\\x08@\\x00\\x00\\x00\\x00\\x00\\x00\\x10@'
        >>> abs(v1)
        5.0
        >>> bool(v1), bool(Vector([0, 0]))
        (True, False)
    
    
    Test of ``.frombytes()`` class method:
    
        >>> v1_clone = Vector.frombytes(bytes(v1))
        >>> v1_clone
        Vector([3.0, 4.0])
        >>> v1 == v1_clone
        True
    
    
    Tests with 3-dimensions::
    
        >>> v1 = Vector([3, 4, 5])
        >>> x, y, z = v1
        >>> x, y, z
        (3.0, 4.0, 5.0)
        >>> v1
        Vector([3.0, 4.0, 5.0])
        >>> v1_clone = eval(repr(v1))
        >>> v1 == v1_clone
        True
        >>> print(v1)
        (3.0, 4.0, 5.0)
        >>> abs(v1)  # doctest:+ELLIPSIS
        7.071067811...
        >>> bool(v1), bool(Vector([0, 0, 0]))
        (True, False)
    
    
    Tests with many dimensions::
    
        >>> v7 = Vector(range(7))
        >>> v7
        Vector([0.0, 1.0, 2.0, 3.0, 4.0, ...])
        >>> abs(v7)  # doctest:+ELLIPSIS
        9.53939201...
    
    
    Test of ``.__bytes__`` and ``.frombytes()`` methods::
    
        >>> v1 = Vector([3, 4, 5])
        >>> v1_clone = Vector.frombytes(bytes(v1))
        >>> v1_clone
        Vector([3.0, 4.0, 5.0])
        >>> v1 == v1_clone
        True
    
    
    Tests of sequence behavior::
    
        >>> v1 = Vector([3, 4, 5])
        >>> len(v1)
        3
        >>> v1[0], v1[len(v1)-1], v1[-1]
        (3.0, 5.0, 5.0)
    
    
    Test of slicing::
    
        >>> v7 = Vector(range(7))
        >>> v7[-1]
        6.0
        >>> v7[1:4]
        Vector([1.0, 2.0, 3.0])
        >>> v7[-1:]
        Vector([6.0])
        >>> v7[1,2]
        Traceback (most recent call last):
          ...
        TypeError: Vector indices must be integers
    
    
    Tests of dynamic attribute access::
    
        >>> v7 = Vector(range(10))
        >>> v7.x
        0.0
        >>> v7.y, v7.z, v7.t
        (1.0, 2.0, 3.0)
    
    Dynamic attribute lookup failures::
    
        >>> v7.k
        Traceback (most recent call last):
          ...
        AttributeError: 'Vector' object has no attribute 'k'
        >>> v3 = Vector(range(3))
        >>> v3.t
        Traceback (most recent call last):
          ...
        AttributeError: 'Vector' object has no attribute 't'
        >>> v3.spam
        Traceback (most recent call last):
          ...
        AttributeError: 'Vector' object has no attribute 'spam'
    
    
    Tests of hashing::
    
        >>> v1 = Vector([3, 4])
        >>> v2 = Vector([3.1, 4.2])
        >>> v3 = Vector([3, 4, 5])
        >>> v6 = Vector(range(6))
        >>> hash(v1), hash(v3), hash(v6)
        (7, 2, 1)
    
    
    Most hash values of non-integers vary from a 32-bit to 64-bit CPython build::
    
        >>> import sys
        >>> hash(v2) == (384307168202284039 if sys.maxsize > 2**32 else 357915986)
        True
    
    
    Tests of ``format()`` with Cartesian coordinates in 2D::
    
        >>> v1 = Vector([3, 4])
        >>> format(v1)
        '(3.0, 4.0)'
        >>> format(v1, '.2f')
        '(3.00, 4.00)'
        >>> format(v1, '.3e')
        '(3.000e+00, 4.000e+00)'
    
    
    Tests of ``format()`` with Cartesian coordinates in 3D and 7D::
    
        >>> v3 = Vector([3, 4, 5])
        >>> format(v3)
        '(3.0, 4.0, 5.0)'
        >>> format(Vector(range(7)))
        '(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0)'
    
    
    Tests of ``format()`` with spherical coordinates in 2D, 3D and 4D::
    
        >>> format(Vector([1, 1]), 'h')  # doctest:+ELLIPSIS
        '<1.414213..., 0.785398...>'
        >>> format(Vector([1, 1]), '.3eh')
        '<1.414e+00, 7.854e-01>'
        >>> format(Vector([1, 1]), '0.5fh')
        '<1.41421, 0.78540>'
        >>> format(Vector([1, 1, 1]), 'h')  # doctest:+ELLIPSIS
        '<1.73205..., 0.95531..., 0.78539...>'
        >>> format(Vector([2, 2, 2]), '.3eh')
        '<3.464e+00, 9.553e-01, 7.854e-01>'
        >>> format(Vector([0, 0, 0]), '0.5fh')
        '<0.00000, 0.00000, 0.00000>'
        >>> format(Vector([-1, -1, -1, -1]), 'h')  # doctest:+ELLIPSIS
        '<2.0, 2.09439..., 2.18627..., 3.92699...>'
        >>> format(Vector([2, 2, 2, 2]), '.3eh')
        '<4.000e+00, 1.047e+00, 9.553e-01, 7.854e-01>'
        >>> format(Vector([0, 1, 0, 0]), '0.5fh')
        '<1.00000, 1.57080, 0.00000, 0.00000>'
    """
    
    from array import array
    import reprlib
    import math
    import numbers
    import functools
    import operator
    import itertools  # <1>
    
    
    class Vector:
        typecode = 'd'
    
        def __init__(self, components):
            self._components = array(self.typecode, components)
    
        def __iter__(self):
            return iter(self._components)
    
        def __repr__(self):
            components = reprlib.repr(self._components)
            components = components[components.find('['):-1]
            return 'Vector({})'.format(components)
    
        def __str__(self):
            return str(tuple(self))
    
        def __bytes__(self):
            return (bytes([ord(self.typecode)]) +
                    bytes(self._components))
    
        def __eq__(self, other):
            return (len(self) == len(other) and
                    all(a == b for a, b in zip(self, other)))
    
        def __hash__(self):
            hashes = (hash(x) for x in self)
            return functools.reduce(operator.xor, hashes, 0)
    
        def __abs__(self):
            return math.sqrt(sum(x * x for x in self))
    
        def __bool__(self):
            return bool(abs(self))
    
        def __len__(self):
            return len(self._components)
    
        def __getitem__(self, index):
            cls = type(self)
            if isinstance(index, slice):
                return cls(self._components[index])
            elif isinstance(index, numbers.Integral):
                return self._components[index]
            else:
                msg = '{.__name__} indices must be integers'
                raise TypeError(msg.format(cls))
    
        shortcut_names = 'xyzt'
    
        def __getattr__(self, name):
            cls = type(self)
            if len(name) == 1:
                pos = cls.shortcut_names.find(name)
                if 0 <= pos < len(self._components):
                    return self._components[pos]
            msg = '{.__name__!r} object has no attribute {!r}'
            raise AttributeError(msg.format(cls, name))
    
        def angle(self, n):  # <2>
            r = math.sqrt(sum(x * x for x in self[n:]))
            a = math.atan2(r, self[n-1])
            if (n == len(self) - 1) and (self[-1] < 0):
                return math.pi * 2 - a
            else:
                return a
    
        def angles(self):  # <3>
            return (self.angle(n) for n in range(1, len(self)))
    
        def __format__(self, fmt_spec=''):
            if fmt_spec.endswith('h'):  # hyperspherical coordinates
                fmt_spec = fmt_spec[:-1]
                coords = itertools.chain([abs(self)],
                                         self.angles())  # <4>
                outer_fmt = '<{}>'  # <5>
            else:
                coords = self
                outer_fmt = '({})'  # <6>
            components = (format(c, fmt_spec) for c in coords)  # <7>
            return outer_fmt.format(', '.join(components))  # <8>
    
        @classmethod
        def frombytes(cls, octets):
            typecode = chr(octets[0])
            memv = memoryview(octets[1:]).cast(typecode)
            return cls(memv)
    # END VECTOR_V5
    

     

    展开全文
  • vector 存放内置数据类型 #include<iostream> using namespace std;... //创建了一个vector容器,数组 vector<int> v; //向容器中插入数据 v.push_back(10);//尾插法 v.push_back(20); v.
  • ptr_vector-一个指针的容器

    千次阅读 2014-04-23 18:10:12
    值语义变得很明显的,当您尝试存储在一个标准集装箱,如指针,在一个std::vector的。你立刻感受到"阻抗失配"标准的矢量值之间的接口和存储的指针一个额外的*(解引用)是必要的,达到指向的对象。这是烦人的,尤其...
  • C++ 通过指针访问vector中的元素失效问题解决方案
  • int main() { vector svec; cout string str; cin >> str ; //接收字符串 string *pstr = new string; //动态分配内存 pstr = &str; svec.push_back(pstr);
  • 最近用到vector中存储结构体: struct sProc { // 进程ID int pid; // 进程状态 int stat; // 状态为0次数 int count; char *path; sProc() { pid = -1; stat = 0; count = 0; path = NULL...
  • C++定义了内容丰富的抽象数据类型标准库。...这二者是语言组成部分中更基本的数据类型数组和指针的抽象。 现将两对的主要区别简要陈述: 、数组与vector: 1、vector是数组的抽象,首先,用户程序使用v...
  • unique_ptr:不允许多个指针共享资源,可以用标准库中的move函数转移指针shared_ptr:多个指针共享资源weak_ptr:可复制shared_ptr,但其构造或者释放对资源不产生影响 6.11 vector对象为什么需要vector?  ...
  • 1.存放自定义类型的方式 容器:vector 迭代器:vector<monkey>::iterator #include<...//存放自定义指针类型 class Monkey { //创建一个猴子的类 public: Monkey(string name,int ...
  • 我正在学习C++ PRIMER,第五章有个5.18题目,说要定义一个vector对象,每个元素都是指向string类型指针 我用了以下两种方式,VC++ 6.0都提示错误了: #include <vector> using std::vector; ...... ...
  • 数组、指针vector、迭代器

    千次阅读 2012-12-30 22:09:24
    数组和指针概念也深入人心,vector和迭代器体现了C++的优越性,然而并不多见于普通程序中。此文深入讨论这4种数据结构的概念和使用。  定义数组的长度必须用常量,如 int n[10];  或: int
  • 标准库类型vector

    2017-04-30 21:29:32
    标准库类型vector表示对象的集合,其中所有对象的类型都相同。集合中的每个对象都有一个与之对应的索引,索引用于访问对象。因为vector“容纳着”其他对象,所以它也常被称作container(容器)。 vector的初始化...
  • vector中保存类的指针类型时,在使用remove或者erase进行元素的删除时,需要防止内存泄露的发生。一般保存到vector中的元素都是手工new出来的对象,这些对象在必须手工进行销毁以防止内存泄露。 vector的remove或者...
  • 指针类型定义

    千次阅读 2017-09-08 15:57:18
    类型定义的语法可以归结为句话:只要在变量定义前面加上typedef,就成了类型定义。这儿的原本应该是变量的东西,就成为了类型。 int integer; //整型变量 int *pointer; //整型指针变量 int array [5]; //...
  • vector 类型

    2013-06-27 16:26:31
    点击打开链接vector类为内置数组提供了一种替代表示,与string类一样 vector 类是随标准 C++引入的标准库的一部分 ,为了使用vector 我们必须包含...1. 定义一个已知长度的 vectorvector ivec( 10 ); //类似数
  • 容器 vector指针的学习

    千次阅读 2018-01-16 18:43:19
    在c++语言中,模板容器是一个十分重要的知识点。今天主要学习了vector这个容器,这个容器内是数组,存储的数据是连续的。vector声明定义完成后,可以向该vector压入数据,具体用到的是push_back()这个vector自带的...
  • .使用包含#include <vector> using namespace std;...2、动态创建m*n的二维vector:方法vector<vector<int> > arr; (注意后有空格或者使用typedef定义) arr.resize(m); for(int i=0;i;i++)
  • STL源码之实现一个简易的Vector容器  这里需要的基础知识主要是类模板和函数模板,以及一个C++内存分配的技术allocator类,它提供可感知类型的内存分配,这个类支持一个抽象接口,以分配内存并随后使用该内存...
  • //为了方便,要包含的文件会不同,但我没有删 #include <iostream><br />#include <string><br />#include <vector> #include <bitset><br />#include  //和C语言的string.h其实是一个版本 ...
  • vector容器类型

    千次阅读 2011-11-30 15:26:02
    vector类为内置数组提供了一种替代表示,与string类一样 vector 类是随标准 C++引入的标准库的一部分 ,为了使用vector 我们必须包含相关...1. 定义一个已知长度的 vectorvector ivec( 10 ); //类似数组定义int i
  • vector的声明要想使用vector,...vector一个类模板。②初始化vector对象vector<T> v1; //v1是空得里面装的是T类型 vector<T> v2(v1); //v2包含V1里面的所有元素的副本 vector<T> v2 = v1; //等价v2(v1); vector<T
  • vector容器与迭代器,数组与指针

    千次阅读 2013-07-16 11:16:56
    vector容器与数组非常相似,他们都存放一组具有相同类型数据的元素,其元素是以连续的方式存放——每一个元素紧挨着前一个元素存储。他们的元素没有独立的名字,所以对元素进行访问时都需要一种相应迭代器来历遍元素...
  • Vector是C++标准库类型,称为容器,一个容器中的所有对象必须是同一种类型的。与数组相比,其最大的优点就是动态增长。Vector一个类模板,并不是数据类型,而vectorvector才是数据类型。其下标的类型vector::...
  • 指针类型

    千次阅读 2006-11-25 19:56:00
    C++数据类型和链表list 并管理在程序执行过程中动态分配的对象以及作为函数参数类型主要用来传递数组或大型的类对象每个指针都有一个相关的类型不同数据类型指针之间的区别不是在指针的表示上也不在指针所持有的值...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,022
精华内容 32,008
关键字:

如何定义一个指针类型的vector