使用date还需要代码写入其长度吗？

在MySQL中，DATE类型的长度是固定的，即3个字节，因为DATE类型只包含年、月、日三个信息，不包含时间。因此，在创建表时指定长度是没有意义的。您可以使用以下命令创建一个包含DATE类型列的表：

CREATE TABLE 表名 (
    列名 DATE
);

在插入数据时，您可以使用以下格式来插入日期值：

INSERT INTO 表名 (列名) VALUES ('YYYY-MM-DD');

其中，YYYY表示年份，MM表示月份，DD表示日。需要注意的是，日期值必须用单引号括起来。如果您想要插入当前日期，可以使用NOW()函数或者CURDATE()函数，例如：

INSERT INTO 表名 (列名) VALUES (NOW());

这样就会插入当前日期。

相关问题

使用 java 对文件进行pgp加密的完整工具类代码

下面是一个使用 BouncyCastle 实现 PGP 加密和解密的 Java 工具类示例：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import java.util.Date;
import java.util.Iterator;

import org.bouncycastle.bcpg.ArmoredOutputStream;
import org.bouncycastle.bcpg.CompressionAlgorithmTags;
import org.bouncycastle.bcpg.HashAlgorithmTags;
import org.bouncycastle.bcpg.SymmetricKeyAlgorithmTags;
import org.bouncycastle.bcpg.sig.Features;
import org.bouncycastle.bcpg.sig.KeyFlags;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.openpgp.PGPEncryptedData;
import org.bouncycastle.openpgp.PGPEncryptedDataGenerator;
import org.bouncycastle.openpgp.PGPException;
import org.bouncycastle.openpgp.PGPLiteralData;
import org.bouncycastle.openpgp.PGPObjectFactory;
import org.bouncycastle.openpgp.PGPOnePassSignatureList;
import org.bouncycastle.openpgp.PGPPrivateKey;
import org.bouncycastle.openpgp.PGPPublicKey;
import org.bouncycastle.openpgp.PGPPublicKeyEncryptedData;
import org.bouncycastle.openpgp.PGPPublicKeyRing;
import org.bouncycastle.openpgp.PGPPublicKeyRingCollection;
import org.bouncycastle.openpgp.PGPSecretKey;
import org.bouncycastle.openpgp.PGPSecretKeyRing;
import org.bouncycastle.openpgp.PGPSecretKeyRingCollection;
import org.bouncycastle.openpgp.PGPUtil;

public class PgpEncryptDecryptUtil {

    private static final String PROVIDER = "BC";
    private static final int BUFFER_SIZE = 4096;

    // 加载 BouncyCastle 提供的 JCE 供应商
    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    /**
     * 加密数据并输出到指定的输出流中
     *
     * @param data         要加密的数据
     * @param publicKeyIn  加载公钥的输入流
     * @param outputStream 输出加密后的数据的输出流
     * @throws IOException  IO异常
     * @throws PGPException PGP异常
     */
    public static void encrypt(byte[] data, InputStream publicKeyIn, OutputStream outputStream)
            throws IOException, PGPException {
        // 创建公钥环
        PGPPublicKeyRingCollection publicKeyRingCollection = new PGPPublicKeyRingCollection(
                PGPUtil.getDecoderStream(publicKeyIn));
        // 找到可用的公钥
        PGPPublicKey publicKey = null;
        Iterator<PGPPublicKeyRing> keyRingIterator = publicKeyRingCollection.getKeyRings();
        while (publicKey == null && keyRingIterator.hasNext()) {
            PGPPublicKeyRing keyRing = keyRingIterator.next();
            Iterator<PGPPublicKey> keyIterator = keyRing.getPublicKeys();
            while (publicKey == null && keyIterator.hasNext()) {
                PGPPublicKey key = keyIterator.next();
                if (key.isEncryptionKey()) {
                    publicKey = key;
                }
            }
        }
        if (publicKey == null) {
            throw new IllegalArgumentException("Can't find public key");
        }

        // 创建加密数据生成器
        PGPEncryptedDataGenerator encryptedDataGenerator = new PGPEncryptedDataGenerator(
                new JcePGPDataEncryptorBuilder(SymmetricKeyAlgorithmTags.AES_256)
                        .setWithIntegrityPacket(true).setSecureRandom(new SecureRandom()).setProvider(PROVIDER));
        encryptedDataGenerator.addMethod(new JcePublicKeyKeyEncryptionMethodGenerator(publicKey)
                .setProvider(PROVIDER));

        // 创建压缩输出流
        ByteArrayOutputStream compressedOutputStream = new ByteArrayOutputStream();
        OutputStream compressedDataOutputStream = new ArmoredOutputStream(compressedOutputStream);
        PGPCompressedDataGenerator compressedDataGenerator = new PGPCompressedDataGenerator(
                CompressionAlgorithmTags.ZIP);
        OutputStream compressedDataOutputStream2 = compressedDataGenerator.open(compressedDataOutputStream);

        // 创建字面数据输出流
        PGPLiteralDataGenerator literalDataGenerator = new PGPLiteralDataGenerator();
        OutputStream literalDataOutputStream = literalDataGenerator.open(compressedDataOutputStream2, PGPLiteralData.BINARY,
                PGPLiteralData.CONSOLE, data.length, new Date());

        // 写入明文数据
        ByteArrayInputStream dataInputStream = new ByteArrayInputStream(data);
        byte[] buffer = new byte[BUFFER_SIZE];
        int length;
        while ((length = dataInputStream.read(buffer, 0, buffer.length)) != -1) {
            literalDataOutputStream.write(buffer, 0, length);
        }
        literalDataOutputStream.close();

        // 关闭输出流
        compressedDataGenerator.close();
        compressedDataOutputStream.close();
        compressedOutputStream.close();

        // 加密数据并输出到指定输出流
        byte[] encryptedData = compressedOutputStream.toByteArray();
        OutputStream encryptedDataOutputStream = encryptedDataGenerator.open(outputStream, encryptedData.length);
        encryptedDataOutputStream.write(encryptedData);
        encryptedDataOutputStream.close();
    }

    /**
     * 解密数据并返回解密后的数据
     *
     * @param encryptedDataIn 加载加密数据的输入流
     * @param privateKeyIn    加载私钥的输入流
     * @return 解密后的数据
     * @throws IOException  IO异常
     * @throws PGPException PGP异常
     */
    public static byte[] decrypt(InputStream encryptedDataIn, InputStream privateKeyIn)
            throws IOException, PGPException {
        // 创建私钥环
        PGPSecretKeyRingCollection secretKeyRingCollection = new PGPSecretKeyRingCollection(
                PGPUtil.getDecoderStream(privateKeyIn));
        // 找到可用的私钥
        PGPPrivateKey privateKey = null;
        Iterator<PGPSecretKeyRing> keyRingIterator = secretKeyRingCollection.getKeyRings();
        while (privateKey == null && keyRingIterator.hasNext()) {
            PGPSecretKeyRing keyRing = keyRingIterator.next();
            Iterator<PGPSecretKey> keyIterator = keyRing.getSecretKeys();
            while (privateKey == null && keyIterator.hasNext()) {
                PGPSecretKey key = keyIterator.next();
                if (key.isSigningKey()) {
                    privateKey = key.extractPrivateKey(new JcePBESecretKeyDecryptorBuilder()
                            .setProvider(PROVIDER).build("".toCharArray()));
                }
            }
        }
        if (privateKey == null) {
            throw new IllegalArgumentException("Can't find private key");
        }

        // 创建对象工厂
        PGPObjectFactory objectFactory = new PGPObjectFactory(PGPUtil.getDecoderStream(encryptedDataIn));
        Object object = objectFactory.nextObject();

        // 找到加密数据包
        PGPEncryptedData encryptedData = null;
        while (encryptedData == null && object != null) {
            if (object instanceof PGPEncryptedData) {
                encryptedData = (PGPEncryptedData) object;
            } else {
                object = objectFactory.nextObject();
            }
        }
        if (encryptedData == null) {
            throw new IllegalArgumentException("Can't find encrypted data");
        }

        // 找到公钥并解密数据
        InputStream encryptedDataInputStream = encryptedData.getDataStream(new JcePublicKeyDataDecryptorFactoryBuilder()
                .setProvider(PROVIDER).build(privateKey));
        PGPObjectFactory encryptedObjectFactory = new PGPObjectFactory(encryptedDataInputStream);
        object = encryptedObjectFactory.nextObject();

        // 找到签名列表并校验签名
        PGPOnePassSignatureList signatureList = null;
        while (signatureList == null && object != null) {
            if (object instanceof PGPOnePassSignatureList) {
                signatureList = (PGPOnePassSignatureList) object;
            } else {
                object = encryptedObjectFactory.nextObject();
            }
        }
        if (signatureList != null) {
            throw new PGPException("This implementation doesn't support signed data");
        }

        // 找到字面数据包并解压缩数据
        PGPLiteralData literalData = null;
        while (literalData == null && object != null) {
            if (object instanceof PGPLiteralData) {
                literalData = (PGPLiteralData) object;
            } else {
                object = encryptedObjectFactory.nextObject();
            }
        }
        if (literalData == null) {
            throw new IllegalArgumentException("Can't find literal data");
        }
        ByteArrayOutputStream uncompressedOutputStream = new ByteArrayOutputStream();
        InputStream compressedDataInputStream = literalData.getInputStream();
        PGPCompressedData compressedData = new PGPCompressedData(compressedDataInputStream);
        InputStream uncompressedDataInputStream = compressedData.getDataStream();
        byte[] buffer = new byte[BUFFER_SIZE];
        int length;
        while ((length = uncompressedDataInputStream.read(buffer, 0, buffer.length)) != -1) {
            uncompressedOutputStream.write(buffer, 0, length);
        }
        uncompressedDataInputStream.close();
        compressedDataInputStream.close();
        uncompressedOutputStream.close();

        return uncompressedOutputStream.toByteArray();
    }

    /**
     * 加载公钥环
     *
     * @param publicKeyRingIn 加载公钥环的输入流
     * @return 公钥环
     * @throws IOException  IO异常
     * @throws PGPException PGP异常
     */
    public static PGPPublicKeyRingCollection loadPublicKeyRing(InputStream publicKeyRingIn)
            throws IOException, PGPException {
        return new PGPPublicKeyRingCollection(PGPUtil.getDecoderStream(publicKeyRingIn));
    }

    /**
     * 加载私钥环
     *
     * @param secretKeyRingIn 加载私钥环的输入流
     * @return 私钥环
     * @throws IOException  IO异常
     * @throws PGPException PGP异常
     */
    public static PGPSecretKeyRingCollection loadSecretKeyRing(InputStream secretKeyRingIn)
            throws IOException, PGPException {
        return new PGPSecretKeyRingCollection(PGPUtil.getDecoderStream(secretKeyRingIn));
    }

    /**
     * 从文件中加载公钥环
     *
     * @param publicKeyRingFile 加载公钥环的文件
     * @return 公钥环
     * @throws IOException  IO异常
     * @throws PGPException PGP异常
     */
    public static PGPPublicKeyRingCollection loadPublicKeyRingFromFile(String publicKeyRingFile)
            throws IOException, PGPException {
        FileInputStream fileInputStream = new FileInputStream(publicKeyRingFile);
        PGPPublicKeyRingCollection publicKeyRingCollection = loadPublicKeyRing(fileInputStream);
        fileInputStream.close();
        return publicKeyRingCollection;
    }

    /**
     * 从文件中加载私钥环
     *
     * @param secretKeyRingFile 加载私钥环的文件
     * @return 私钥环
     * @throws IOException  IO异常
     * @throws PGPException PGP异常
     */
    public static PGPSecretKeyRingCollection loadSecretKeyRingFromFile(String secretKeyRingFile)
            throws IOException, PGPException {
        FileInputStream fileInputStream = new FileInputStream(secretKeyRingFile);
        PGPSecretKeyRingCollection secretKeyRingCollection = loadSecretKeyRing(fileInputStream);
        fileInputStream.close();
        return secretKeyRingCollection;
    }

    /**
     * 保存公钥环到文件中
     *
     * @param publicKeyRing        要保存的公钥环
     * @param publicKeyRingFileOut 保存公钥环的文件输出流
     * @throws IOException IO异常
     */
    public static void savePublicKeyRing(PGPPublicKeyRing publicKeyRing, OutputStream publicKeyRingFileOut)
            throws IOException {
        ArmoredOutputStream armoredOutputStream = new ArmoredOutputStream(publicKeyRingFileOut);
        publicKeyRing.encode(armoredOutputStream);
        armoredOutputStream.close();
    }

    /**
     * 保存私钥环到文件中
     *
     * @param secretKeyRing        要保存的私钥环
     * @param secretKeyRingFileOut 保存私钥环的文件输出流
     * @throws IOException IO异常
     */
    public static void saveSecretKeyRing(PGPSecretKeyRing secretKeyRing, OutputStream secretKeyRingFileOut)
            throws IOException {
        ArmoredOutputStream armoredOutputStream = new ArmoredOutputStream(secretKeyRingFileOut);
        secretKeyRing.encode(armoredOutputStream);
        armoredOutputStream.close();
    }

    /**
     * 保存公钥环到文件中
     *
     * @param publicKeyRing        要保存的公钥环
     * @param publicKeyRingFileOut 保存公钥环的文件输出流
     * @throws IOException IO异常
     */
    public static void savePublicKeyRingToFile(PGPPublicKeyRing publicKeyRing, String publicKeyRingFileOut)
            throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream(publicKeyRingFileOut);
        savePublicKeyRing(publicKeyRing, fileOutputStream);
        fileOutputStream.close();
    }

    /**
     * 保存私钥环到文件中
     *
     * @param secretKeyRing        要保存的私钥环
     * @param secretKeyRingFileOut 保存私钥环的文件输出流
     * @throws IOException IO异常
     */
    public static void saveSecretKeyRingToFile(PGPSecretKeyRing secretKeyRing, String secretKeyRingFileOut)
            throws IOException {
        FileOutputStream fileOutputStream = new FileOutputStream(secretKeyRingFileOut);
        saveSecretKeyRing(secretKeyRing, fileOutputStream);
        fileOutputStream.close();
    }

    /**
     * 创建公钥环
     *
     * @param keyPair             密钥对
     * @param userId              用户ID
     * @param keyRingName         密钥环名称
     * @param expirationTimeInDays 过期时间（以天为单位）
     * @return 公钥环
     * @throws PGPException PGP异常
     */
    public static PGPPublicKeyRing createPublicKeyRing(PgpKeyPair keyPair, String userId, String keyRingName,
                                                        int expirationTimeInDays) throws PGPException {
        PGPPublicKeyRingGenerator publicKeyRingGenerator = new PGPPublicKeyRingGenerator(
                PGPSignature.POSITIVE_CERTIFICATION, keyPair.getPublicKey(), userId,
                new JcePBESecretKeyEncryptorBuilder(PGPEncryptedData.AES_256, new SecureRandom())
                        .setProvider(PROVIDER).build(keyPair.getPassphrase().toCharArray()),
                null, null, new JcaPGPContentSignerBuilder(keyPair.getPublicKey().getAlgorithm(),
                HashAlgorithmTags.SHA256), new JcePGPKeyEncryptionMethodGenerator(keyPair.getPublicKey().getAlgorithm())
                .setProvider(PROVIDER), new SecureRandom(), new Date());
        if (expirationTimeInDays > 0) {
            publicKeyRingGenerator.addSubKey(keyPair.getPublicKey(),
                    new Date(System.currentTimeMillis() + expirationTimeInDays * 86400000L),
                    new JcaPGPContentSignerBuilder(keyPair.getPublicKey().getAlgorithm(),
                            HashAlgorithmTags.SHA256),
                    new JcePGPKeyEncryptionMethodGenerator(keyPair.getPublicKey().getAlgorithm()).setProvider(PROVIDER));
        }
        return publicKeyRingGenerator.generatePublicKeyRing();
    }

    /**
     * 创建私钥环
     *
     * @param keyPair             密钥对
     * @param userId              用户ID
     * @param keyRingName         密钥环名称
     * @param expirationTimeInDays 过期时间（以天为单位）
     * @return 私钥环
     * @throws PGPException PGP异常
     */
    public static PGPSecretKeyRing createSecretKeyRing(PgpKeyPair keyPair, String userId, String keyRingName,
                                                        int expirationTimeInDays) throws PGPException {
        PGPPublicKey publicKey = keyPair.getPublicKey();
        PGPSecretKey secretKey = new PGPSecretKey(PGPSignature.DEFAULT_CERTIFICATION, publicKey,
                new JcaPGPContentSignerBuilder(publicKey.getAlgorithm(), HashAlgorithmTags.SHA256),
                new JcePBESecretKeyEncryptorBuilder(PGPEncryptedData.AES_256, new SecureRandom())
                        .setProvider(PROVIDER).build(keyPair.getPassphrase().toCharArray()), null, null,
                new JcaPGPContentSignerBuilder(publicKey.getAlgorithm(), HashAlgorithmTags.SHA256),
                new JcePGPKeyEncryptionMethodGenerator(publicKey.getAlgorithm()).setProvider(PROVIDER));
        if (expirationTimeInDays > 0) {
            secretKey = PGPSecretKey.addSecretSubKey(secretKey, keyPair.getPrivateKey(),
                    new Date(System.currentTimeMillis() + expirationTimeInDays * 86400000L),
                    new JcaPGPContentSignerBuilder(publicKey.getAlgorithm(), HashAlgorithmTags.SHA256),
                    new JcePGPKeyEncryptionMethodGenerator(publicKey.getAlgorithm()).setProvider(PROVIDER));
        }
        return new PGPSecretKeyRing(secretKey.getEncoded());
    }

    /**
     * 创建密钥对
     *
     * @param keySize    密钥长度
     * @param passphrase 密码
     * @return 密钥对
     * @throws PGPException PGP异常
     */
    public static PgpKeyPair createKeyPair(int keySize, String passphrase) throws PGPException {
        JcaPGPKeyPairGenerator keyPairGenerator = new JcaPGPKeyPairGenerator().setProvider(PROVIDER);
        keyPairGenerator.generate(keySize, new SecureRandom());
        PGPKeyPair keyPair = keyPairGenerator.generateKeyPair();
        return new PgpKeyPair(keyPair.getPublicKey(), keyPair.getPrivateKey(), passphrase);
    }

    /**
     * 加载密钥对
     *
     * @param publicKeyIn  加载公钥的输入流
     * @param privateKeyIn 加载私钥的输入流
     * @param passphrase   密码
     * @return 密钥对
     * @throws IOException  IO异常
     * @throws PGPException PGP异常
     */
    public static PgpKeyPair loadKeyPair(InputStream publicKeyIn, InputStream privateKeyIn, String passphrase)
            throws IOException,

c++ 写shp、shx、dbf的详细代码

写shp、shx、dbf文件的代码需要涉及到很多的细节，下面是一个简单的示例代码：

1. 写shp文件

// 定义shape类型，这里以点为例
struct Point {
    double x;
    double y;
};

// 写入shp文件
void writeShpFile(const char* filename, Point* points, int numPoints) {
    // 打开文件
    FILE* fp = fopen(filename, "wb");
    if (!fp) {
        printf("open file failed: %s\n", filename);
        return;
    }

    // 写入文件头
    int fileCode = 9994; // 文件标识
    int unused[5] = { 0 }; // 未使用的5个字段
    int fileLength = 2 * sizeof(int) + 2 * sizeof(double) + sizeof(int) + numPoints * (4 + sizeof(Point)); // 文件长度
    int version = 1000; // 版本号
    int shapeType = 1; // shape类型，这里为点
    double minX = points[0].x; // x的最小值
    double minY = points[0].y; // y的最小值
    double maxX = points[0].x; // x的最大值
    double maxY = points[0].y; // y的最大值
    for (int i = 1; i < numPoints; i++) {
        minX = std::min(minX, points[i].x);
        minY = std::min(minY, points[i].y);
        maxX = std::max(maxX, points[i].x);
        maxY = std::max(maxY, points[i].y);
    }
    fwrite(&fileCode, sizeof(int), 1, fp);
    fwrite(unused, sizeof(int), 5, fp);
    fwrite(&fileLength, sizeof(int), 1, fp);
    fwrite(&version, sizeof(int), 1, fp);
    fwrite(&shapeType, sizeof(int), 1, fp);
    fwrite(&minX, sizeof(double), 1, fp);
    fwrite(&minY, sizeof(double), 1, fp);
    fwrite(&maxX, sizeof(double), 1, fp);
    fwrite(&maxY, sizeof(double), 1, fp);
    fwrite(unused, sizeof(double), 2, fp);

    // 写入每个点的信息
    for (int i = 0; i < numPoints; i++) {
        int recordNumber = i + 1; // 记录号
        int contentLength = sizeof(Point); // 内容长度
        fwrite(&recordNumber, sizeof(int), 1, fp);
        fwrite(&contentLength, sizeof(int), 1, fp);
        fwrite(&points[i], sizeof(Point), 1, fp);
    }

    // 关闭文件
    fclose(fp);
}

2. 写shx文件

// 写入shx文件
void writeShxFile(const char* filename, int numPoints) {
    // 打开文件
    FILE* fp = fopen(filename, "wb");
    if (!fp) {
        printf("open file failed: %s\n", filename);
        return;
    }

    // 写入文件头
    int fileCode = 9994; // 文件标识
    int unused[5] = { 0 }; // 未使用的5个字段
    int fileLength = 2 * sizeof(int) + numPoints * 8; // 文件长度
    int version = 1000; // 版本号
    int shapeType = 1; // shape类型，这里为点
    fwrite(&fileCode, sizeof(int), 1, fp);
    fwrite(unused, sizeof(int), 5, fp);
    fwrite(&fileLength, sizeof(int), 1, fp);
    fwrite(&version, sizeof(int), 1, fp);
    fwrite(&shapeType, sizeof(int), 1, fp);

    // 写入每个记录的偏移量和长度
    int offset = 50; // 第一个记录的偏移量
    for (int i = 0; i < numPoints; i++) {
        int contentLength = sizeof(Point); // 内容长度
        fwrite(&offset, sizeof(int), 1, fp);
        fwrite(&contentLength, sizeof(int), 1, fp);
        offset += contentLength + 4;
    }

    // 关闭文件
    fclose(fp);
}

3. 写dbf文件

// 定义每个字段的类型
enum FieldType {
    FT_Char = 'C', // 字符串
    FT_Numeric = 'N', // 数字
    FT_Date = 'D', // 日期
    FT_Logical = 'L', // 逻辑值
};

// 定义每个字段的信息
struct FieldInfo {
    char name[11]; // 字段名，最多10个字符
    FieldType type; // 字段类型
    int length; // 字段长度
    int decimalCount; // 小数位数
};

// 写入dbf文件
void writeDbfFile(const char* filename, Point* points, int numPoints) {
    // 打开文件
    FILE* fp = fopen(filename, "wb");
    if (!fp) {
        printf("open file failed: %s\n", filename);
        return;
    }

    // 写入文件头
    char version = 3; // 版本号
    int year = 2021; // 最后更新日期的年份
    int month = 9; // 最后更新日期的月份
    int day = 1; // 最后更新日期的日份
    int numRecords = numPoints; // 记录数
    int headerLength = 32 + sizeof(FieldInfo); // 文件头长度
    int recordLength = 1 + sizeof(Point); // 记录长度
    int unused[2] = { 0 }; // 未使用的2个字段
    char languageDriver = 0x03; // 代码页标识
    fwrite(&version, sizeof(char), 1, fp);
    fwrite(&year, sizeof(int), 1, fp);
    fwrite(&month, sizeof(char), 1, fp);
    fwrite(&day, sizeof(char), 1, fp);
    fwrite(&numRecords, sizeof(int), 1, fp);
    fwrite(&headerLength, sizeof(short), 1, fp);
    fwrite(&recordLength, sizeof(short), 1, fp);
    fwrite(unused, sizeof(int), 2, fp);
    fwrite(&languageDriver, sizeof(char), 1, fp);

    // 写入每个字段的信息
    FieldInfo fieldInfo;
    memset(&fieldInfo, 0, sizeof(FieldInfo));
    strcpy(fieldInfo.name, "ID");
    fieldInfo.type = FT_Numeric;
    fieldInfo.length = 10;
    fieldInfo.decimalCount = 0;
    fwrite(&fieldInfo, sizeof(FieldInfo), 1, fp);

    // 写入每条记录的信息
    for (int i = 0; i < numPoints; i++) {
        fwrite(&i, sizeof(char), 1, fp);
        fwrite(&points[i], sizeof(Point), 1, fp);
    }

    // 关闭文件
    fclose(fp);
}

这里只是一个简单的示例，实际情况下，写入shp、shx、dbf文件的代码可能更加复杂，需要根据具体的需求进行设计和实现。