SampleTable和SampleIterator的初始化和设置

最新推荐文章于 2022-01-10 17:10:02 发布
最新推荐文章于 2022-01-10 17:10:02 发布
阅读量1.5k 收藏
点赞数
分类专栏： android多媒体
包含转化媒体时间到实际的sample的信息，是一个容器，包含下面的所有的表
if (chunk_type ==  FOURCC('s', 't', 'b', 'l')) {
      ALOGV("sampleTable chunk is %d bytes long.", (size_t)chunk_size);
      mLastTrack->sampleTable =  new SampleTable(mDataSource);
}
初始化所有变量的值，主要是各个boxer数据部分的偏移地址，以便于调用readAt函数读取解析
SampleTable::SampleTable(const sp &source)
      : mDataSource(source),
         mChunkOffsetOffset(-1),
         mChunkOffsetType(0),
         mNumChunkOffsets(0),
         mSampleToChunkOffset(-1),
         mNumSampleToChunkOffsets (0),
         mSampleSizeOffset(-1),
         mSampleSizeFieldSize(0),
         mDefaultSampleSize(0),
         mNumSampleSizes(0),
         mTimeToSampleCount(0),
         mTimeToSample(NULL),
         mSampleTimeEntries(NULL),
         mCompositionTimeDeltaEnt ries(NULL),
         mNumCompositionTimeDelta Entries(0),
         mCompositionDeltaLookup(new CompositionDeltaLookup),
         mSyncSampleOffset(-1),
         mNumSyncSamples(0),
         mSyncSamples(NULL),
         mLastSyncSampleIndex(0),
         mSampleToChunkEntries(NULL) {
      mSampleIterator = new SampleIterator(this);
}
SampleIterator::SampleIterator(SampleTable *table)
      : mTable(table),
         mInitialized(false),
         mTimeToSampleIndex(0),
         mTTSSampleIndex(0),
         mTTSSampleTime(0),
         mTTSCount(0),
         mTTSDuration(0) {
      reset();
}

void SampleIterator::reset() {
      mSampleToChunkIndex = 0;
      mFirstChunk = 0;
      mFirstChunkSampleIndex = 0;
      mStopChunk = 0;
      mStopChunkSampleIndex = 0;
      mSamplesPerChunk = 0;
      mChunkDesc = 0;
}
==============================================================
http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7925.html
每个chunk的相对于文件起始位置的偏移
            case FOURCC('s', 't', 'c', 'o'):
            case FOURCC('c', 'o', '6', '4'):
            {
                  status_t err =
                        mLastTrack-> sampleTable->setChunkOffsetParams(
                                    chunk_type, data_offset, chunk_data_size);
                  *offset += chunk_size;
                  break;
            }
status_t SampleTable::setChunkOffsetParams(
            uint32_t type, off64_t data_offset, size_t data_size) {
      if (mChunkOffsetOffset >= 0) {
            return ERROR_MALFORMED;
      }

      CHECK(type == kChunkOffsetType32 || type == kChunkOffsetType64);
       stco boxer数据部分的偏移位置
       mChunkOffsetOffset = data_offset;
      mChunkOffsetType = type;

       uint8_t header[8];   //用来解析数据段的前八个字节
      if (mDataSource->readAt(
                        data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
            return ERROR_IO;
      }

      if ( U32_AT(header) != 0) {
            // Expected version = 0, flags = 0.
            return ERROR_MALFORMED;
      }

      mNumChunkOffsets = U32_AT(&header[4]);
chunk的数目，每个chunk具体文件开始的便宜用4个字节或者八个字节来记录，
以四个字节为例子：
第一个chunk的便宜位置：U32_AT(&header[mChunkOffsetOffset+ 8+0*4])；
第二个chunk的便宜位置：U32_AT(&header[mChunkOffsetOffset+ 8+1*4])；
第三个chunk的便宜位置：U32_AT(&header[mChunkOffsetOffset+ 8+2*4])；
第四个chunk的便宜位置：U32_AT(&header[mChunkOffsetOffset+ 8+3*4])；
....

      if (mChunkOffsetType == kChunkOffsetType32) {
            if (data_size < 8 + mNumChunkOffsets * 4) {
                  return ERROR_MALFORMED;
            }
      } else {
            if (data_size < 8 + mNumChunkOffsets * 8) {
                  return ERROR_MALFORMED;
            }
      }
      return OK;
}
===========================================================
http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7922.html
sample to chunk，也即是当前这个sample在哪一个chunk
            case FOURCC('s', 't', 's', 'c'):
            {
                  status_t err =
                        mLastTrack->sampleTable-> setSampleToChunkParams(
                                    data_offset, chunk_data_size);
                  *offset += chunk_size;
                  break;
            }

status_t SampleTable::setSampleToChunkParams(
            off64_t data_offset, size_t data_size) {
    mSampleToChunkOffset = data_offset;
      uint8_t header[8];
      if (mDataSource->readAt(
                        data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
            return ERROR_IO;
      }
      if (U32_AT(header) != 0) {
            // Expected version = 0, flags = 0.
            return ERROR_MALFORMED;
      }
       mNumSampleToChunkOffsets = U32_AT(&header[4]);

      if (data_size < 8 +  mNumSampleToChunkOffsets * 12) {
            return ERROR_MALFORMED;
      }

      mSampleToChunkEntries =
            new SampleToChunkEntry[mNumSampleToChunkOffsets ];

      for (uint32_t i = 0; i < mNumSampleToChunkOffsets ; ++i) {
            uint8_t buffer[12];
            if (mDataSource->readAt(
                              mSampleToChunkOffset + 8 + i * 12, buffer, sizeof(buffer))
                        != (ssize_t)sizeof(buffer)) {
                  return ERROR_IO;
            }
            CHECK(U32_AT(buffer) >= 1);   // chunk index is 1 based in the spec.
            // We want the chunk index to be 0-based.
            mSampleToChunkEntries[i].startChunk = U32_AT(buffer) - 1;
            mSampleToChunkEntries[i].samplesPerChunk = U32_AT(&buffer[4]);
            mSampleToChunkEntries[i].chunkDesc = U32_AT(&buffer[8]);
      }
每个sampleToChunk占12个字节：每四个字节表示不同的含义
偏移地址计算公式：mSampleToChunkOffset + 8 + i * 12
每四字节的含义：
1：这个table使用的第一个chunk序号
2：当前trunk内的sample数目
3：与这些sample关联的sample description的序号
      return OK;
}
===================================================
http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7924.html
stsz 记录了每个sample的大小以及全部sample的数目
            case FOURCC('s', 't', 's', 'z'):
            case FOURCC('s', 't', 'z', '2'):
            {
                  status_t err =
                        mLastTrack->sampleTable-> setSampleSizeParams(
                                    chunk_type, data_offset, chunk_data_size);
                  size_t max_size;
                  err =  mLastTrack->sampleTable->getMaxSampleSize(&max_size);

                  // Assume that a given buffer only contains at most 10 fragments,
                  // each fragment originally prefixed with a 2 byte length will
                  // have a 4 byte header (0x00 0x00 0x00 0x01) after conversion,
                  // and thus will grow by 2 bytes per fragment.
                   mLastTrack->meta->setInt32(kKeyMaxInputSize, max_size + 10 * 2);
                  *offset += chunk_size;

                   // Calculate average frame rate.
计算公式看起来非常简单： 总时长/总的帧数
                  const char *mime;
                  CHECK(mLastTrack->meta->findCString(kKeyMIMEType, &mime));
                  if (!strncasecmp("video/", mime, 6)) {
                        size_t nSamples = mLastTrack->sampleTable->countSamples();
                        int64_t durationUs;
                        if (mLastTrack->meta->findInt64(kKeyDuration, &durationUs)) {
                              if (durationUs > 0) {
                                     int32_t frameRate = (nSamples * 1000000LL +
                                    (durationUs >> 1)) / durationUs;
                                    mLastTrack->meta->setInt32(kKeyFrameRate, frameRate);
                              }
                        }
                  }
                  break;
            }
status_t SampleTable::setSampleSizeParams(
            uint32_t type, off64_t data_offset, size_t data_size) {
    mSampleSizeOffset = data_offset;
      uint8_t header[12];
      if (mDataSource->readAt(
                        data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
            return ERROR_IO;
      }
      if (U32_AT(header) != 0) {
            // Expected version = 0, flags = 0.
            return ERROR_MALFORMED;
      }
    mDefaultSampleSize = U32_AT(&header[4]);  默认的每一个sample的大小，如果大于0，则表示所有的sample大小一致，即为 mDefaultSampleSize
    mNumSampleSizes = U32_AT(&header[8]);     sample的数目
      if (type == kSampleSizeType32) {
             mSampleSizeFieldSize = 32;用四个字节来表示每一个sample的大小，所以数据去总长度不能小于12 + mNumSampleSizes * 4
            if (mDefaultSampleSize != 0) {
                  return OK;
            }
            if ( data_size < 12 + mNumSampleSizes * 4) {
                  return ERROR_MALFORMED;
            }
      } else {
            if ((mDefaultSampleSize & 0xffffff00) != 0) {
                  // The high 24 bits are reserved and must be 0.
                  return ERROR_MALFORMED;
            }
             mSampleSizeFieldSize = mDefaultSampleSize & 0xff;用来表示sample大小的字节数
            mDefaultSampleSize = 0;
            if (mSampleSizeFieldSize != 4 && mSampleSizeFieldSize != 8
                  && mSampleSizeFieldSize != 16) {
                  return ERROR_MALFORMED;
            }
            if (data_size < 12 + (mNumSampleSizes * mSampleSizeFieldSize + 4) / 8) {
                  return ERROR_MALFORMED;
            }
      }
      return OK;
}
下面的各个函数是计算每一个sample的大小，然后选择大小最大的那个，就是四字节四字节的读取
status_t SampleTable::getMaxSampleSize(size_t *max_size) {
      Mutex::Autolock autoLock(mLock);
      *max_size = 0;
      for ( uint32_t i = 0; i < mNumSampleSizes; ++i) {   循环获取每个sample的大小
            size_t sample_size;
            status_t err = getSampleSize_l(i, &sample_size);
            if (sample_size > *max_size) {
                  *max_size = sample_size;
            }
      }
      return OK;
}
status_t SampleTable::getSampleSize_l(
            uint32_t sampleIndex, size_t *sampleSize) {
      return mSampleIterator->getSampleSizeDirect(
                  sampleIndex, sampleSize);
}
status_t SampleIterator::getSampleSizeDirect(
            uint32_t sampleIndex, size_t *size) {
      *size = 0;
      if (sampleIndex >= mTable->mNumSampleSizes) {
            return ERROR_OUT_OF_RANGE;
      }
      if (mTable->mDefaultSampleSize > 0) {
            *size = mTable->mDefaultSampleSize;
            return OK;
      }
      switch (mTable->mSampleSizeFieldSize) {
            case 32:
            {
                                     红色部分为每一个sample的偏移位置
                  if (mTable->mDataSource->readAt(
                                     mTable->mSampleSizeOffset + 12 + 4 * sampleIndex,
                                    size, sizeof(*size)) < (ssize_t)sizeof(*size)) {
                        return ERROR_IO;
                  }
                  *size = ntohl(*size);
                  break;
            }
            case 16:
            {
                  uint16_t x;
                  if (mTable->mDataSource->readAt(
                                    mTable->mSampleSizeOffset + 12 + 2 * sampleIndex,
                                    &x, sizeof(x)) < (ssize_t)sizeof(x)) {
                        return ERROR_IO;
                  }
                  *size = ntohs(x);
                  break;
            }
            case 8:
            {
                  uint8_t x;
                  if (mTable->mDataSource->readAt(
                                    mTable->mSampleSizeOffset + 12 + sampleIndex,
                                    &x, sizeof(x)) < (ssize_t)sizeof(x)) {
                        return ERROR_IO;
                  }
                  *size = x;
                  break;
            }
            default:
            {
                  CHECK_EQ(mTable->mSampleSizeFieldSize, 4);
                  uint8_t x;
                  if (mTable->mDataSource->readAt(
                                    mTable->mSampleSizeOffset + 12 + sampleIndex / 2,
                                    &x, sizeof(x)) < (ssize_t)sizeof(x)) {
                        return ERROR_IO;
                  }
                  *size = (sampleIndex & 1) ? x & 0x0f : x >> 4;
                  break;
            }
      }
      return OK;
}
===================================================
http://www.52rd.com/blog/Detail_RD.Blog_wqyuwss_7920.html
每一个时间点映射到具体的sample上，Time-to-sample atoms存储了media sample的duration信息，提供了时间对具体data sample的映射方法，通过这个atom，你可以找到任何时间的sample
            case FOURCC('s', 't', 't', 's'):
            {
                  status_t err =
                        mLastTrack->sampleTable-> setTimeToSampleParams(
                                    data_offset, chunk_data_size);
                  *offset += chunk_size;
                  break;
            }
status_t SampleTable::setTimeToSampleParams(
            off64_t data_offset, size_t data_size) {
      uint8_t header[8];
      if (mDataSource->readAt(
                        data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
            return ERROR_IO;
      }
      if ( U32_AT(header) != 0) {
            // Expected version = 0, flags = 0.
            return ERROR_MALFORMED;
      }
       mTimeToSampleCount = U32_AT(&header[4]);
      mTimeToSample = new uint32_t[mTimeToSampleCount * 2];   这里为什么要乘2呢？？？
      size_t size = sizeof(uint32_t) *  mTimeToSampleCount * 2;
       mTimeToSample每个元素占四个字节，最后得到mTimeToSample这张表
      if (mDataSource->readAt(
                        data_offset + 8, mTimeToSample, size) < (ssize_t)size) {
            return ERROR_IO;
      }
      for (uint32_t i = 0; i <  mTimeToSampleCount * 2; ++i) {
            mTimeToSample[i] = ntohl(mTimeToSample[i]);
      }
      return OK;
}
========================================================

            case FOURCC('c', 't', 't', 's'):
            {
                  status_t err =
                        mLastTrack->sampleTable->setCompositionTimeToSamp leParams(
                                    data_offset, chunk_data_size);
                  *offset += chunk_size;
                  break;
            }
status_t SampleTable::setCompositionTimeToSamp leParams(
            off64_t data_offset, size_t data_size) {
      ALOGI("There are reordered frames present.");
      if (mCompositionTimeDeltaEnt ries != NULL || data_size < 8) {
            return ERROR_MALFORMED;
      }
      uint8_t header[8];
      if (mDataSource->readAt(
                        data_offset, header, sizeof(header))
                  < (ssize_t)sizeof(header)) {
            return ERROR_IO;
      }
      if (U32_AT(header) != 0) {
            // Expected version = 0, flags = 0.
            return ERROR_MALFORMED;
      }
      size_t numEntries = U32_AT(&header[4]);
      if (data_size != (numEntries + 1) * 8) {
            return ERROR_MALFORMED;
      }
      mNumCompositionTimeDelta Entries = numEntries;
      mCompositionTimeDeltaEnt ries = new uint32_t[2 * numEntries];
      if (mDataSource->readAt(
                        data_offset + 8, mCompositionTimeDeltaEnt ries, numEntries * 8)
                  < (ssize_t)numEntries * 8) {
            delete[] mCompositionTimeDeltaEnt ries;
            mCompositionTimeDeltaEnt ries = NULL;
            return ERROR_IO;
      }
      for (size_t i = 0; i < 2 * numEntries; ++i) {
            mCompositionTimeDeltaEnt ries[i] = ntohl(mCompositionTimeDeltaEnt ries[i]);
      }
      mCompositionDeltaLookup->setEntries(
                  mCompositionTimeDeltaEnt ries, mNumCompositionTimeDelta Entries);
      return OK;
}
==================================================
http://www.cnblogs.com/haibindev/archive/2011/10/17/2214518.html
可随机访问的sample列表，关键帧列表
            case FOURCC('s', 't', 's', 's'):
            {
                  status_t err =
                        mLastTrack->sampleTable->setSyncSampleParams(
                                    data_offset, chunk_data_size);
                  *offset += chunk_size;
                  break;
            }
status_t SampleTable::setSyncSampleParams(off64_t data_offset, size_t data_size) {
       mSyncSampleOffset = data_offset;
      uint8_t header[8];
      if (mDataSource->readAt(
                        data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
            return ERROR_IO;
      }
      if ( U32_AT(header) != 0) {
            // Expected version = 0, flags = 0.
            return ERROR_MALFORMED;
      }
       mNumSyncSamples = U32_AT(&header[4]);
      if (mNumSyncSamples < 2) {
            ALOGV("Table of sync samples is empty or has only a single entry!");
      }
       mSyncSamples = new uint32_t[mNumSyncSamples];  用四个字节来记录关键帧的
      size_t size = mNumSyncSamples * sizeof(uint32_t);
      if (mDataSource->readAt( mSyncSampleOffset + 8, mSyncSamples, size)
                  != (ssize_t)size) {
            return ERROR_IO;
      }
      for (size_t i = 0; i < mNumSyncSamples; ++i) {
            mSyncSamples[i] = ntohl(mSyncSamples[i]) - 1;
      }
      return OK;
}
创造晴天81
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MySQL 数量庞大的Sample Table
weixin_45943151的博客
05-22 135
The Employees database is available fromEmployees DB on GitHub（登录该网站下载）. You can download a prepackaged archive of the data, or access the information through Git. To use the Zip archive package, download the archive and unpack it usingWinZipor anothe...
mp4文件结构
wangbuji的博客
12-03 5327
一、基本概念 1.mp4概述 MP4文件中的所有数据都装在box（QuickTime中为atom）中，也就是说MP4文件由若干个box组成，每个box有类型和长度，可以将box理解为一个数据对象块。box中可以包含另一个box，这种box称为container box。一个MP4文件首先
示波器采样
dh0144298的专栏
06-16 6183
http://bbs.eeworld.com.cn/thread-1071205-1-1.html 带宽 　　带宽、采样率和存储深度是数字示波器的三大关键指标。带宽一直被称作示波器的第一性能指标，也成了决定示波器价格很重要的因素，市场上也把带宽作为一个划分依据，通常所说的带宽在无特别说明情况下一般指模拟放大器的带宽，也就是常说的-3dB截止频率点。示波器面板上标称的带宽就是我们常说的示波器带宽。究竟什么是示波器的带宽我们可以这样来理解：在示波器输入端输入正弦波信号时，幅度衰减至原信号幅度的0...
【转】simulink中的sample time设置
kldy2008的博客
04-10 3万+
初次接触simulink中的不同模块，在仿真时，因为对sample time 设置不够清晰导致仿真出现了很多错误，查了不少文献，走了不少弯路，才找到官方的解释和设置方法，放在这里仅供参考。更多内容请参考官方指南： https://ww2.mathworks.cn/help/simulink/ug/how-to-specify-the-sample-time.html 指定采样时间 Simul...
MP4文件格式解析 之 二 （Sample table atom ）
lxmnet123的专栏
08-31 5077
http://www.52rd.com/Blog/Detail_RD.Blog_wqyuwss_7934.html                  C   stbal           sample table atom                   存储媒体数据的单位是samples。一个sample是一系列按时间顺序排列的数据的一个element。Samples存储在media中
Bootstrap table表格初始化表格数据的方法
10-18
Bootstrap Table 是一个流行的前端组件，用于创建美观、响应式的表格。在本文中，我们将深入探讨如何初始化Bootstrap Table的表格数据...通过理解和应用上述配置选项，你可以根据项目需求灵活地初始化和管理表格数据。
layui之table checkbox初始化时选中对应选项的方法
10-16
本文将详细讲解如何在layui的table初始化时设置checkbox选中对应的选项。 首先，layui table组件在渲染数据时，需要从后台获取数据并将其格式化为特定的结构。对于包含checkbox的表格，每个行数据需要包含一个字段...
Layui table field初始化加载时进行隐藏的方法
10-16
本文将详细介绍如何在Layui table初始化加载时隐藏特定字段。 在Layui的table字段配置中，实现字段隐藏的方法是利用`hide`属性。这个属性是专门为控制字段可见性设计的，只需要在定义字段时设置`hide`为`true`，就...
C#中数组初始化、反转和排序用法实例
12-31
本文实例讲述了C#中数组初始化、反转和排序用法。分享给大家供大家参考。具体如下： 下面的代码演示了在C#中定义和初始化数组，然后对其进行赋值，排序和反转的操作方法： using System; public class ArraySample ...
Fixed-step size(Solver)、Sample time(模块)、Sample time(powergui)三者的辨析
奇妙水果的技术博客，欢迎交流技术~
11-11 4468
设计了一个仿真模型，尝试对Fixed-step size(Solver中)、Sample time(模块中)、Sample time(powergui中)三者进行辨析。
Java 迭代器Iterator的详解
热门推荐
重心开始，重新开始
07-26 5万+
为了方便的处理集合中的元素,Java中出现了一个对象,该对象提供了一些方法专门处理集合中的元素.例如删除和获取集合中的元素.该对象就叫做迭代器(Iterator). 对 Collection 进行迭代的类，称其为迭代器。还是面向对象的思想，专业对象做专业的事情，迭代器就是专门取出集合元素的对象。但是该对象比较特殊，不能直接创建对象（通过new），该对象是以内部类的形式存在于每个集合类的内部。
C++迭代器（STL迭代器）iterator详解
天涯路的专栏
11-14 751
要访问顺序容器和关联容器中的元素，需要通过“迭代器（iterator）”进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。 迭代器按照定义方式分成以下四种。 正向迭代器，定义方法如下： 容器类名::iterator 迭代器名; 常量正向迭代器，定义方法如下： 容器类名::cons...
Hive学习之抽样（tablesample）
houzhizhen的专栏
01-10 986
当数据量特别大时，对全体数据进行处理存在困难时，抽样就显得尤其重要了。抽样可以从被抽取的数据中估计和推断出整体的特性，是科学实验、质量检验、社会调查普遍采用的一种经济有效的工作和研究方法。 Hive支持桶表抽样和块抽样，下面分别学习。所谓桶表指的是在创建表时使用CLUSTERED BY子句创建了桶的表。桶表抽样的语法如下： table_sample: TABLESAMPLE (BUCKET x OUT OF y [ON colname]) TABLESAMPLE子句允许用户编写用于数据抽样而不是整个表
Tegra3 1080p高清播放时电源管理方式和功耗分析
tudusi
02-17 155
此案例分析Tegra3（采用vSMP架构，4+1核心）在执行1080p播放时PM的运行情况，使用的平台是ASUA Eee Pad，运行Android 3.2。 先播放少女时代1080p演唱会x264，Japan.First.Tour.Girls'Generation.2011.BluRay.1080p.DTS.x264-CHD Nvidia 1080p硬件解码： 02-16 23:01:01....
音频采样率，时间戳分析
矩阵实验室
11-14 2880
1. FFmpeg一个音频帧信息：2. pkt durationpkt_duration = nb_samples / sample_rate sample_rate = 48000 nb_samples = 1024 pkt_duration = 1024 / 48000 = 0.021333 3. 显示时间与ptspresentation_time = pts / sample_
Hive学习之抽样（Sampling）
skyWalker_ONLY
09-18 2万+
当数据量特别大时，对全体数据进行处理存在困难时，抽样就显得尤其重要了。抽样可以从被抽取的数据中估计和推断出整体的特性，是科学实验、质量检验、社会调查普遍采用的一种经济有效的工作和研究方法。 Hive支持桶表抽样和块抽样，下面分别学习。所谓桶表指的是在创建表时使用CLUSTERED BY子句创建了桶的表。桶表抽样的语法如下： table_sample: TABLESAMPLE (BUCKET x
Hive的HQL语句及数据倾斜解决方案
weixin_34327223的博客
06-14 358
[版权申明：本文系作者原创，转载请注明出处] 文章出处：http://blog.csdn.net/sdksdk0/article/details/51675005 作者： 朱培 ID：sdksdk0 Hive环境的搭建在这里也不重复说了，安装配置可以查看我的这篇文章：http://blog.csdn.net/sdksdk...
Hive实现随机抽样（附详解）
qq_654603797
01-05 9177
select * from tab order by rand() limit 1000 select * from ( select e.*, cast(rand() * 100000 as int) as idx from e ) t order by t.idx limit 1000 表e为一个普通的表，里面存有数据，我们要从表e中随机抽出1000条数据作为数据样本。 2，ran...
C++迭代器iterator详解
大秦坑王的专栏
04-12 2万+
知识的学习在于点滴记录，坚持不懈；知识的学习要有深度和广度，不能只流于表面，坐井观天；知识要善于总结，不仅能够理解，更知道如何表达！ 目录迭代器概念iterator迭代器实现容器迭代器失效问题const_iterator迭代器实现reverse_iterator迭代器实现const_reverse_iterator迭代器实现insert插入型迭代器流迭代器 迭代器概念 最近有人春招面试互联网大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值