Início / user-25993933

timmy george's questions

Martin Hope
timmy george
Asked: 2025-04-15 13:01:57 +0800 CST
  • 6

O conteúdo de um arquivo de texto chamado existingfile.txté o seguinte

The First Order Derivative of X2 is
2x. The derivative of sin is cos.
Math is the best

O código abaixo é de um arquivo chamado main.cppque está no mesmo diretório que existingfile.txt O exemplo mostra o processo de

  • abrindo uma alça paraexistingfile.txt
  • obtendo o tamanho deexistingfile.txt
  • lendo 1000 bytes deexistingfile.txt
  • gerando uma matriz de caracteres de 1000 bytes até o primeiro terminador nulo
#include <windows.h>
#include <cstdio>

int main(int, char**){
//Creating Synchronous File Handle
    HANDLE hFile = CreateFileW(
        L"existingfile.txt",
        GENERIC_READ,
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        OPEN_ALWAYS,
        FILE_FLAG_SEQUENTIAL_SCAN,
        NULL
    );
    if (hFile == INVALID_HANDLE_VALUE) {
        printf("ERROR IN OPENING FILE %lu\n", GetLastError());
        return -1;
    }
    //Obtaining File Size
    {
        ULARGE_INTEGER FileSize;
        FileSize.LowPart = GetFileSize(hFile, &FileSize.HighPart);
        DWORD LastError = GetLastError();
        if (FileSize.LowPart == INVALID_FILE_SIZE && LastError != NO_ERROR){
            printf("FAILED TO OBTAIN FILE SIZE, ERROR %lu\n", LastError);
            return -1;
        }
        printf("FILE SIZE: %llu\n", FileSize.QuadPart);
    }
    //Reading To End Of the File
    {
        OVERLAPPED Overlapped = {};
        Overlapped.Offset = 15;
        Overlapped.OffsetHigh = 0;
        constexpr DWORD NumBytesToRead = 1000;
        char BytesRead[NumBytesToRead + 1] = {0};
        BOOL Successful = ReadFile(hFile, BytesRead, NumBytesToRead, NULL, &Overlapped);
        DWORD LastError = GetLastError();
        if (!Successful){
            if (LastError != ERROR_HANDLE_EOF){
                printf("ERROR IN OVERLAPPED SYNCHRONOUS READ TO EOF, ERROR %lu\n", LastError);
                return -1;
            }
            puts("EOF ENCOUNTERED IN OVERLAPPED SYNCHRONOUS READ TO EOF");
        }
        BytesRead[NumBytesToRead] = 0;
        printf("2: Information Read: '%s'\n", BytesRead); 
    }
    CloseHandle(hFile);
    return 0;
}

A saída que obtenho é

FILE SIZE: 88
2: Information Read: ' Derivative of X2 is
2x. The derivative of sin is cos.
Math is the best'

A saída que eu esperava era

FILE SIZE: 88
EOF ENCOUNTERED IN OVERLAPPED SYNCHRONOUS READ TO EOF
2: Information Read: ' Derivative of X2 is
2x. The derivative of sin is cos.
Math is the best'

porque está declarado na documentação do ReadFile

Considerações para trabalhar com identificadores de arquivo síncronos:

...

Se lpOverlapped não for NULL, quando uma operação de leitura síncrona atingir o final de um arquivo, ReadFile retornará FALSE e GetLastError retornará ERROR_HANDLE_EOF.

Eu ficaria muito grato se alguém pudesse explicar/descobrir a causa do porquê o comportamento esperado mencionado na documentação não está acontecendo.

c++
Martin Hope
timmy george
Asked: 2024-12-30 00:47:20 +0800 CST
  • 15

O seguinte é um exemplo de brinquedo

A classe studenttem um std::array<char, 15>chamado namee um inteiro age. Um aluno tem uma função membro chamada encodeque chama uma função de modelo global encodeusando name.size()como parâmetro de modelo.

O código é mostrado abaixo:

//main.cpp
#include <iostream>
#include <array>

template <unsigned long num1>
unsigned long encode(unsigned long num2){
    return num1 + num2;
}


struct student {
    std::array<char, 15> name;
    int age;
    student(const std::array<char, 15>& name, int age):
        name(name),
        age(age)
    {}
    unsigned long encode(){
        return ::encode<name.size()>(age);
    }
};

int main(){
    std::array<char, 15> name = {"Tim"};
    student Tim(name, 17);
    std::cout << Tim.encode();
}

No entanto, isso produz o seguinte erro do compilador

>g++ main.cpp -std=c++11

main.cpp: In member function 'long unsigned int student::encode()':
main.cpp:22:43: error: use of 'this' in a constant expression
   22 |                 return ::encode<name.size()>(age);
      |                                           ^
main.cpp:22:45: error: no matching function for call to 'encode<((student*)this)->student::name.std::array<char, 15>::size()>(int&)'
   22 |                 return ::encode<name.size()>(age);
      |                        ~~~~~~~~~~~~~~~~~~~~~^~~~~
main.cpp:9:15: note: candidate: 'template<long unsigned int num1> long unsigned int encode(long unsigned int)'
    9 | unsigned long encode(unsigned long num2){
      |               ^~~~~~
main.cpp:9:15: note:   template argument deduction/substitution failed:
main.cpp:22:45: error: use of 'this' in a constant expression
   22 |                 return ::encode<name.size()>(age);
      |                        ~~~~~~~~~~~~~~~~~~~~~^~~~~
main.cpp:22:42: note: in template argument for type 'long unsigned int'
   22 |                 return ::encode<name.size()>(age);

É necessário que eu faça isso ::encode<15>(age)para resolver esse problema, porque eu acho que um dos principais benefícios de um std::arrayé poder carregar um tamanho em vez de ter que armazenar o tamanho em alguma variável extra (ou codificar o tamanho).

g++ version: 14.1.0

c++
Martin Hope
timmy george
Asked: 2024-12-14 03:10:10 +0800 CST
  • 10

vectoré uma estrutura com dois membros públicos Xe Y; um construtor parametrizado que imprime integer constructor called; um construtor de cópia que imprime copy constructor called; e um construtor de movimento que imprime move constructor called <== This line is different\n.

A função makeVectorx5y5IfNotZero()retorna o vetor {5, 5}se argfor 0. caso contrário, retorna {2, 2}.

A mainfunção constrói vector Ausando makeVectorx5y5IfNotZero(1)e constrói vector Busando makeVectorx5y5IfNotZero(0).

Aqui está o código:

#include <iostream>

struct vector{
    int X, Y;
    vector(int X, int Y) : X(X), Y(Y){
        printf("integer constructor called\n");
    }
    vector(const vector& other): X(other.X), Y(other.Y){
        printf("copy constructor called\n");
    }
    vector(vector&& other): X(other.X), Y(other.Y){
        printf("move constructor called      <== This line is different\n\n");
    }
};

vector makeVectorx5y5IfNotZero(bool Arg){
    if(Arg){
        vector A(0, 0);
        A.X = 5;
        A.Y = 5;
        return A;
    }
    else {
        vector B(1,1);
        B.X = 2;
        B.Y = 2;
        return B;
    }
}

int main(){
    printf("Making Vector\n");
    vector A = makeVectorx5y5IfNotZero(1);
    printf("Made Vector\n");
    printf("Making Another Vector\n");
    vector B = makeVectorx5y5IfNotZero(0);
    printf("Made Vector\n");
}

A saída deste código é:

Making Vector
integer constructor called
Made Vector
Making Another Vector
integer constructor called
move constructor called      <== This line is different
Made Vector

No entanto, eu esperava o seguinte resultado, por causa do NRVO:

Making Vector
integer constructor called
Made Vector
Making Another Vector
integer constructor called
Made Vector

Por que a variável local Bde makeVectorx5y5IfNotZero()está sendo movida para a variável local Bde main(), em vez de apenas construir uma única variável no mesmo endereço de memória?

Versão do compilador (saída de g++ --version):

g++ (Rev3, Built by MSYS2 project) 14.1.0
Copyright (C) 2024 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
c++
Martin Hope
timmy george
Asked: 2024-11-17 05:52:02 +0800 CST
  • 6

Eu tenho uma estrutura de modelo Distanceque usaconstexpr unsigned char mm2cm = 10

Como Distanceé uma classe de modelo, devo definir mm2cme Distanceem um arquivo de cabeçalho.

Este arquivo de cabeçalho é incluído nos arquivos cpp.

Quero mm2cmque ele fique visível apenas neste arquivo de cabeçalho e não nos arquivos cpp que incluem este cabeçalho, ou seja:

Distância.hpp

constexpr unsigned char mm2cm = 10;

template <int offset>
struct Distance{
    int mm;
    int convToCm() const { return offset + mm2cm * mm; }
};

Principal.cpp

#include "Distance.hpp"
#include <iostream>

int main(){
    //I do not want to be able to use mm2mm outside Distance.hpp, as follows
    std::cout << (int)mm2cm << std::endl; 
    
}

Uma maneira de resolver isso é usar #define mm2cm 10and #undef mm2cmno início e no final do arquivo de cabeçalho (em vez de constexpr unsigned char mm2cm = 10.

No entanto, muitas pessoas desencorajam o uso de macros por razões. Este post lista algumas razões pelas quais ), e este site afirma que:

Em geral, a palavra-chave const é preferida para definir constantes e deve ser usada em vez de #define.

Outra maneira de resolver isso é criar mm2cmmum membro estático privado de Distance.

Entretanto, no problema maior que estou tentando resolver, tenho várias variáveis ​​que quero que fiquem visíveis apenas neste arquivo de cabeçalho, e tornar todas elas membros estáticos privados fará com que minha classe pareça feia (em outras palavras, deve haver uma maneira melhor do que esta solução).

Eu ficaria muito grato se alguém pudesse me fornecer a melhor maneira de garantir mm2cmque ele seja visível somente para Distanceou somente dentro deste arquivo de cabeçalho.

Uma edição anterior deste post usava um parâmetro de modelo de tipo. Isso foi alterado para um parâmetro de modelo não-tipo, já que o problema real que estou tentando resolver usa um parâmetro de modelo não-tipo.

c++