第一课¶

template <class T>
class ObjectArray
{
public:
                            ObjectArray(const uint32 &size);
                            ObjectArray(const ObjectArray &from);
                            ~ObjectArray(void);

    ObjectArray &           operator=(const ObjectArray &from);
    T &                     operator[](int index);

    uint32                  GetSize(void);
private:
    T                       *fData;
    uint32                  fSize;
};

#include <stdio.h>
#include "ObjectArray.h"

int
main(void)
{
    ObjectArray<int32> intArray(10);

    for (uint32 i = 0; i < intArray.GetSize(); i++)
        intArray[i] = intArray.GetSize() - i;

    for (uint32 i = 0; i < intArray.GetSize(); i++)
        printf("intArray[%ld] is %lu\n", i, intArray[i]);
}

template <class T>
ObjectArray<T>::ObjectArray(const uint32 &size)
    :   fData(NULL),
        fSize(size)
{
    if (fSize > 0)
        fData = new T[fSize];
}

template <class T>
ObjectArray<T>::ObjectArray(const ObjectArray &from)
    :   fData(NULL),
        fSize(from.GetSize())
{
    if (fSize > 0)
    {
        fData = new T[fSize];
        for (uint32 i = 0; i < fSize; i++)
            fData[i] = from[i];
    }
}

template <class T>
ObjectArray<T>::~ObjectArray(void)
{
    delete [] fData;
}

template <class T>
ObjectArray<T> &
ObjectArray<T>::operator=(const ObjectArray &from)
{
    if (this == &from)
        return *this;

    delete [] fData;

    fSize = from.GetSize();
    fData = new T[fSize];
    for (uint32 i = 0; i < fSize; i++)
        fData[i] = from[i];
}

template <class T>
T &
ObjectArray<T>::operator[](int index)
{
    return fData[index];
}

template <class T>
uint32
ObjectArray<T>::GetSize(void)
{
    return fSize;
}

class MyClass
{
                                 MyClass(void);
                                 ~MyClass(void);
                         void    SomeRegularFunction(int value);
    template<class T>    void    SomeTemplateFunction(T item);
}

namespace myNamespace
{
   int32 foo, bar;
}

// Note that there is no '.h' for this header and others in the STL. It's
// just <vector>.
#include <vector>
std::vector<int32> intVector;

#include <stdio.h>
bool gSomeFlag = true;
namespace myNamespace
{
    int intValue = 1;
    void
    SomeFunction(void)
    {
        // This specifies the gSomeFlag which is in the default (global)
        // namespace
        if (::gSomeFlag)
            printf("myValue is %d\n", intValue);
    }
} // end myNamespace

#include <deque>
#include <stdio.h>
// This eliminates the need to add the std:: before each reference
// to deque containers.
using std::deque;

int
main(void)
{
    // Declare our deque to accept integers. Without the using statement
    // above, this would read std::deque<int> myDeque. Unless you're
    // using a lot of these, the using statement isn't really needed.
    deque<int> myDeque;

    // Add one element to the end of the list which has a value of 5
    myDeque.push_back(5);

    // Print the number of elements in the deque. In this case, we're
    // definitely not playing with a full deque.
    printf("This deque has %d elements\n", myDeque.size());

    return 0;
}

using namespace std;

#include <stdio.h>
#include <vector>
// This using statement only works for the vector class. It also makes
// the loop code a little more readable.
using std::vector;

int
main(void)
{
    vector<int> myVector;
    // Add a few values to our vector
    myVector.push_back(5);
    myVector.push_back(10);
    myVector.push_back(15);
    // The begin() method will always point to the first item in the
    // container. end() will always point to the last one. This format
    // works for *all* STL containers.
    for (vector<int>::iterator i = myVector.begin(); i != myVector.end(); i++)
    {
        printf("myVector: %d\n", *i);
    }
}

#include <deque>
#include <Directory.h>
#include <Entry.h>
#include <FindDirectory.h>
#include <Path.h>
#include <stdio.h>
using std::deque;

int
main(void)
{

    // Look up the home folder -- this is much preferable to a
    // hard-coded way of accessing a system path.
    BPath path;
    find_directory(B_USER_DIRECTORY, &path);
    BDirectory dir(path.Path());

    deque<entry_ref> refDeque;

    entry_ref ref;
    while (dir.GetNextRef(&ref) == B_OK)
        refDeque.push_back(ref);

    printf("Contents of the home folder: %s\n", path.Path());
    for (deque<entry_ref>::iterator i = refDeque.begin();
         i != refDeque.end(); i++)
    {
        // Note that because an iterator can be treated like
        // a pointer, we can access each entry_ref's name
        // using the iterator.
        printf("\t%s\n", i->name);
    }
}