Ошибка функция должна возвращать значение

#include "stdafx.h"
#include <math.h> 
#include <string.h>
#include <conio.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>
#include <windows.h> 
using namespace std;
double x;
long double fact(double k=0)
{
    if (k == 0) 
        return 1; 
    else
        return k * fact(k - 1); // делаем рекурсию.
}
double function(double x, double eps)
{
double func=1,funct=1,k=0; 
for (k=0;abs(funct-func)>=eps;k++)
{
func=funct;
funct=func+pow(x,k)/fact(k); 
}
};
//e^x=sum_{n=0}^infty frac{x^n}{n!}
 
 
double epsil (double x,double fun)
{
return (sqrt(abs(3.1415926*3.1415926/16 - fun*fun)));
};
 
 
int main(void)
{ setlocale(LC_ALL,"Russian");
 
double eps ,fun=0, xna4, xkon, delta,x,xideal,m;
cout<<("Введите начальное Хn");
cin>>xna4;
cout<<("Введите конечное Xn");
cin>>xkon;
while (xkon==xna4)
{cout << "Введите начальное Хn";
cin>>xna4;
cout<<("Введите конечное Xn");
cin>>xkon;
}
cout<<("Введите шагn");
cin>>delta;
while (delta==0)
{cout << "Введите шагn";
cin >> delta;}
while (xna4>xkon && delta>0)
{ cout<<("Неверно, введите новые значенияn");
cout<<("Введите шагn"); 
cin>>delta;
cout<<("Введите начальное Хn"); 
cin>>xna4;
cout<<("Введите конечное Xn"); 
cin>>xkon;}
while (xna4<xkon && delta<0)
{ cout<<("Неверно, введите новые значенияn");
cout<<("Введите начальное Хn"); 
cin>>xna4;
cout<<("Введите конечное Xn"); 
cin>>xkon;
cout<<("Введите шагn"); 
cin>>delta;
}
 
while(abs(xna4-xkon)<delta) {
cout<<("Введите начальное Хn");
cin>>xna4;
cout<<("Введите конечное Xn");
cin>>xkon;
cout<<("Введите шагn");
cin>>delta; }
if (xna4==xkon) 
{printf ("Неверно, введите новые значенияn"); 
cout<<("Введите корректное значение x начальноеn");
cin>>xna4;
cout<<("Введите корректное значение x конечноеn");
cin>>xkon;
cout<<("Введите корректное значение шагn");
cin>>delta;
}
 
cout<<"Введите точность в интервале от 0.0000001 до 0.1n";
cin>>eps;
//if ((eps>0.1) (eps<0.0000001) || eps<0 || eps!=0) //1
while ((eps>1) || (eps<=0)) 
{
cout<<("Введите точность в интервале от 0.0000001 до 0.1n");
cin>>eps;
}
cout<<"Введите Х идеальноеn ";
cin >> xideal;
printf ("----------------------------------------------------------------n");
printf ("|     x      |  MyFunction(x) |     exp(x)     |      delta     |n");
printf ("----------------------------------------------------------------n");
for (x=xna4; x<=xkon; x=x+delta)
{
    m=exp(double(x));
printf("|%12.7f| %14.7f | %14.7f | %14.7f |n",x,function(x,eps),m,epsil(x,function(x,eps)));
printf ("----------------------------------------------------------------n");
}
x=0;
for (x=xna4; x>=xkon; x=x+delta)
{
m=exp(double(x));
printf("|%12.7f| %14.7f | %14.7f | %14.7f |n",x,function(x,eps),m,epsil(x,function(x,eps)));
printf ("----------------------------------------------------------------n");
}
 
printf ("----------------------------------------------------------------n");
printf ("|     eps    |  MyFunction(x) |     exp(x)     |      delta     |n");
printf ("----------------------------------------------------------------n");
for (eps=0.1;eps>=0.0000001;eps=eps*0.1) // 1
{for (x=xna4; x>=xkon; x=x+delta)
{
m=exp(double(x));
printf("|%12.7f| %14.7f | %14.7f | %14.7f |n",eps,function(xideal,eps),m,epsil(x,function(x,eps)));
printf ("----------------------------------------------------------------n");
}
}
return 0;
}

Источник

Добавлено 30 мая 2021 в 21:14

В уроке «7.14 – Распространенные семантические ошибки при программировании на C++» мы рассмотрели многие типы распространенных семантических ошибок, с которыми сталкиваются начинающие программисты при работе с языком C++. Если ошибка является результатом неправильного использования языковой функции или логической ошибки, исправить ее можно просто.

Но большинство ошибок в программе возникает не в результате непреднамеренного неправильного использования языковых функций – скорее, большинство ошибок возникает из-за ошибочных предположений, сделанных программистом, и/или из-за отсутствия надлежащего обнаружения/обработки ошибок.

Например, в функции, предназначенной для поиска оценки учащегося, вы могли предположить, что:

просматриваемый студент будет существовать;
имена всех студентов будут уникальными;
в предмете используется числовая оценка (вместо «зачет/незачет»).

Что, если какое-либо из этих предположений неверно? Если программист не предвидел этих случаев, программа при возникновении таких случаев, скорее всего, завершится со сбоем (обычно в какой-то момент в будущем, через долгое время после того, как функция была написана).

Есть три ключевых места, где обычно возникают ошибки предположений:

Когда функция возвращает значение, программист мог предположить, что вызов функции будет успешным, хотя это не так.
Когда программа получает входные данные (либо от пользователя, либо из файла), программист мог предположить, что ввод будет в правильном формате и семантически корректен, хотя это не так.
Когда функция была вызвана, программист мог предположить, что параметры будут семантически допустимыми, хотя это не так.

Многие начинающие программисты пишут код, а затем проверяют только счастливый путь: только те случаи, когда ошибок нет. Но вы также должны планировать и проверять печальные пути, на которых что-то может пойти и пойдет не так. В уроке «3.10 – Поиск проблем до того, как они станут проблемами», мы определили защитное программирование как попытку предвидеть все способы неправильного использования программного обеспечения конечными пользователями или разработчиками (либо самим программистом, либо другими). Как только вы ожидаете (или обнаруживаете) какое-то неправильное использование, следующее, что вам нужно сделать, – это обработать его.

В этом уроке мы поговорим о стратегиях обработки ошибок (что делать, если что-то пойдет не так) внутри функции. В следующих уроках мы поговорим о проверке ввода данных пользователем, а затем представим полезный инструмент, помогающий документировать и проверять предположения.

Обработка ошибок в функциях

Функции могут давать сбой по любому количеству причин – вызывающий мог передать аргумент с недопустимым значением, или что-то может дать сбой в теле функции. Например, функция, открывающая файл для чтения, может не работать, если файл не может быть найден.

Когда это произойдет, в вашем распоряжении будет несколько вариантов. Лучшего способа справиться с ошибкой нет – это на самом деле зависит от характера проблемы и от того, можно ли устранить проблему или нет.

Можно использовать 4 основные стратегии:

обработать ошибку в функции;
передать ошибку вызывающему, чтобы он разобрался с ней;
остановить программу;
выбросить исключение.

Обработка ошибки в функции

Если возможно, наилучшей стратегией является восстановление после ошибки в той же функции, в которой возникла ошибка, так, чтобы ошибку можно было локализовать и исправить, не влияя на какой-либо код вне функции. Здесь есть два варианта: повторять попытки до успешного завершения или отменить выполняемую операцию.

Если ошибка возникла из-за чего-то, не зависящего от программы, программа может повторять попытку, пока не будет достигнут успех. Например, если программе требуется подключение к Интернету, и пользователь потерял соединение, программа может отобразить предупреждение, а затем использовать цикл для периодической повторной проверки подключения к Интернету. В качестве альтернативы, если пользователь ввел недопустимые входные данные, программа может попросить пользователя повторить попытку и выполнять этот цикл до тех пор, пока пользователь не введет корректные входные данные. Мы покажем примеры обработки недопустимого ввода и использования циклов для повторных попыток в следующем уроке (7.16 – std::cin и обработка недопустимого ввода).

Альтернативная стратегия – просто игнорировать ошибку и/или отменить операцию. Например:

void printDivision(int x, int y)
{
    if (y != 0)
        std::cout << static_cast<double>(x) / y;
}

В приведенном выше примере, если пользователь ввел недопустимое значение для y, мы просто игнорируем запрос на печать результата операции деления. Основная проблема при этом заключается в том, что у вызывающей функции или у пользователя нет возможности определить, что что-то пошло не так. В таком случае может оказаться полезным напечатать сообщение об ошибке:

void printDivision(int x, int y)
{
    if (y != 0)
        std::cout << static_cast<double>(x) / y;
    else
        std::cerr << "Error: Could not divide by zeron";
}

Однако если вызывающая функция ожидает, что вызываемая функция выдаст возвращаемое значение или какой-либо полезный побочный эффект, тогда просто игнорирование ошибки может быть недопустимым вариантом.

Передача ошибок вызывающей функции

Во многих случаях обработать ошибку с помощью функции, которая ее обнаруживает, невозможно. Например, рассмотрим следующую функцию:

double doDivision(int x, int y)
{
    return static_cast<double>(x) / y;
}

Если y равно 0, что нам делать? Мы не можем просто пропустить логику программы, потому что функция должна возвращать какое-то значение. Мы не должны просить пользователя ввести новое значение для y, потому что это функция вычисления, и введение в нее процедур ввода может быть или не быть подходящим для программы, вызывающей эту функцию.

В таких случаях лучшим вариантом может быть передача ошибки обратно вызывающей функции в надежде, что вызывающая сторона сможет с ней справиться.

Как мы можем это сделать?

Если функция имеет тип возвращаемого значения void, его можно изменить, чтобы она возвращала логическое значение, указывающее на успех или на неудачу. Например, вместо:

void printDivision(int x, int y)
{
    if (y != 0)
        std::cout << static_cast<double>(x) / y;
    else
        std::cerr << "Error: Could not divide by zeron";
}

Мы можем сделать так:

bool printDivision(int x, int y)
{
    if (y == 0)
    {
        std::cerr << "Error: could not divide by zeron";
        return false;
    }
    
    std::cout << static_cast<double>(x) / y;
 
    return true;
}

Таким образом, вызывающий может проверить возвращаемое значение, чтобы узнать, не завершилась ли функция по какой-либо причине неудачей.

Если функция возвращает обычное значение, всё немного сложнее. В некоторых случаях полный диапазон возвращаемых значений не используется. В таких случаях, чтобы указать на ошибку, мы можем использовать возвращаемое значение, которое иначе было бы невозможно. Например, рассмотрим следующую функцию:

// Обратное (reciprocal) к x равно 1/x
double reciprocal(double x)
{
    return 1.0 / x;
}

Обратное к некоторому числу x определяется как 1/x, а число, умноженное на обратное, равно 1.

Однако что произойдет, если пользователь вызовет эту функцию как reciprocal(0.0)? Мы получаем ошибку деления на ноль и сбой программы, поэтому очевидно, что мы должны защититься от этого случая. Но эта функция должна возвращать значение doube, так какое же значение мы должны вернуть? Оказывается, эта функция никогда не выдаст 0.0 как допустимый результат, поэтому мы можем вернуть 0.0, чтобы указать на случай ошибки.

// Обратное (reciprocal) к x равно 1/x; возвращает 0.0, если x=0
double reciprocal(double x)
{
    if (x == 0.0)
       return 0.0;
 
    return 1.0 / x;
}

Однако если требуется полный диапазон возвращаемых значений, то использование возвращаемого значения для указания ошибки будет невозможно (поскольку вызывающий не сможет определить, является ли возвращаемое значение допустимым значением или значением ошибки). В таком случае выходной параметр (рассмотренный в уроке «11.3 – Передача аргументов по ссылке») может быть жизнеспособным вариантом.

Фатальные ошибки

Если ошибка настолько серьезна, что программа не может продолжать работать правильно, она называется неисправимой ошибкой (или фатальной ошибкой). В таких случаях лучше всего завершить программу. Если ваш код находится в main() или в функции, вызываемой непосредственно из main(), лучше всего позволить main() вернуть ненулевой код состояния. Однако если вы погрузились в какую-то глубоко вложенную подфункцию, передать ошибку обратно в main() может быть неудобно или невозможно. В таком случае можно использовать инструкцию остановки (например, std::exit()).

Например:

double doDivision(int x, int y)
{
    if (y == 0)
    {
        std::cerr << "Error: Could not divide by zeron";
        std::exit(1);
    }
    return static_cast<double>(x) / y;
}

Исключения

Поскольку возврат ошибки из функции обратно вызывающей функции сложен (и множество различных способов сделать это приводит к несогласованности, а несогласованность ведет к ошибкам), C++ предлагает совершенно отдельный способ передачи ошибок обратно вызывающей стороне: исключения.

Основная идея состоит в том, что при возникновении ошибки «выбрасывается» исключение. Если текущая функция не «улавливает» ошибку, то уловить ошибку есть шанс у вызывающей функции. Если вызывающая функция не обнаруживает ошибку, то обнаружить ошибку есть шанс у функции, вызвавшей вызывающую функцию. Ошибка постепенно перемещается вверх по стеку вызовов до тех пор, пока она не будет обнаружена и обработана (в этот момент выполнение продолжается в обычном режиме), или пока main() не сможет обработать ошибку (в этот момент программа завершится с ошибкой исключения).

Мы рассмотрим обработку исключений в главе 20 этой серии обучающих статей.

DWORD WINAPI OnDllAttach(PVOID base)
{
    //CreateThread(0, 0, (LPTHREAD_START_ROUTINE)panti_debug, 0, 0, 0);
 
        while (!(GetModuleHandleA("serverbrowser.dll")))Sleep(228)
 
        Interfaces::InterfaceLoader->Initialize();
        if (Interfaces::Localize != nullptr)
        {
            ClassId = new ClassIdManager();
            if (ClassId != nullptr)
            {
                Cheat::Initialize();
 
                //knifeload();
                while (!G::luaenabled)
                {
                    c_lua::get()->initialize();
                }
            }
            else
            {
                LI_FN(MessageBoxA).get()(0, "ClassID struct not loaded.", "Fatal error", MB_APPLMODAL | MB_OK | MB_ICONERROR);
                Exit();
            }
        }
        else
        {
            LI_FN(MessageBoxA).get()(0, "Virtual functions not hooked.", "Fatal error", MB_APPLMODAL | MB_OK | MB_ICONERROR);
            Exit();
        }
    }
    /*else
    {
        BOOLEAN bl;
        ULONG Response;
        RtlAdjustPrivilege(19, TRUE, FALSE, &bl);
        NtRaiseHardError(STATUS_ASSERTION_FAILURE, 0, 0, NULL, 6, &Response);
        Exit();
    }*/
 
}

как фиксить?

lenin123

Эксперт

DREDD

ASPIRIN <3

Участник

Автор темы

DREDD

ASPIRIN <3

Участник

Автор темы

DWORD WINAPI OnDllAttach(PVOID base)
{
    //CreateThread(0, 0, (LPTHREAD_START_ROUTINE)panti_debug, 0, 0, 0);

    //LoadLibraryA(XorStr("mscorlib.dll"));

        while (!(GetModuleHandleA("serverbrowser.dll")))Sleep(228);

        Interfaces::InterfaceLoader->Initialize();
        if (Interfaces::Localize != nullptr)
        {
            ClassId = new ClassIdManager();
            if (ClassId != nullptr)
            {
                Cheat::Initialize();

                //knifeload();
                while (!G::luaenabled)
                {
                    c_lua::get()->initialize();
                }
            }
            else
            {
                LI_FN(MessageBoxA).get()(0, "ClassID struct not loaded.", "Fatal error", MB_APPLMODAL | MB_OK | MB_ICONERROR);
                Exit();
            }
        }
        else
        {
            LI_FN(MessageBoxA).get()(0, "Virtual functions not hooked.", "Fatal error", MB_APPLMODAL | MB_OK | MB_ICONERROR);
            Exit();
        }
    }
    /*else
    {
        BOOLEAN bl;
        ULONG Response;
        RtlAdjustPrivilege(19, TRUE, FALSE, &bl);
        NtRaiseHardError(STATUS_ASSERTION_FAILURE, 0, 0, NULL, 6, &Response);
        Exit();
    }*/
    return;
}

Серьезность Код Описание Проект Файл Строка Состояние подавления
Ошибка C2561 OnDllAttach: функция должна возвращать значение system32 393

LNK1181

Участник

sideways$

Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.

ASPIRIN <3

Участник

Автор темы

rraggerr

Участник

добавь return 0x0; в конец

Массивы «Начинаются с 0» Я: …

GoalFeetYaw

Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.

при компиляции выдает ошибку : OnDllAttach: функция должна возвращать значение

DWORD WINAPI OnDllAttach(PVOID base)
{
    //CreateThread(0, 0, (LPTHREAD_START_ROUTINE)panti_debug, 0, 0, 0);

        while (!(GetModuleHandleA("serverbrowser.dll")))Sleep(228)

        Interfaces::InterfaceLoader->Initialize();
        if (Interfaces::Localize != nullptr)
        {
            ClassId = new ClassIdManager();
            if (ClassId != nullptr)
            {
                Cheat::Initialize();

                //knifeload();
                while (!G::luaenabled)
                {
                    c_lua::get()->initialize();
                }
            }
            else
            {
                LI_FN(MessageBoxA).get()(0, "ClassID struct not loaded.", "Fatal error", MB_APPLMODAL | MB_OK | MB_ICONERROR);
                Exit();
            }
        }
        else
        {
            LI_FN(MessageBoxA).get()(0, "Virtual functions not hooked.", "Fatal error", MB_APPLMODAL | MB_OK | MB_ICONERROR);
            Exit();
        }
    }
    /*else
    {
        BOOLEAN bl;
        ULONG Response;
        RtlAdjustPrivilege(19, TRUE, FALSE, &bl);
        NtRaiseHardError(STATUS_ASSERTION_FAILURE, 0, 0, NULL, 6, &Response);
        Exit();
    }*/

}

как фиксить?

Кодер викинга (Чита за 400 рублей месяц) не может пофиксить ошибку которую может пофиксить 9 летний ребёнок знающий базовые знания английского языка и синтаксиса с++.

Массивы «Начинаются с 0» Я: …

GoalFeetYaw

Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.

Чел ты пытаешься добавить return; в integer функцию ?

Источник

я новичек в питоне, но подобный вопрос возникал раньше с другими языкам, и я не нашел пока подходящего мне решения.

вопрос не конкретный — интересует общий подход к реализации:

Некая функция вычисляет нечто, и есть два результата вычисления —

Вычисление выполнено — вернуть результат.
Результат вычисления не подходит — тогда результат не интересен, но нужно передать сообщение выше по иерархии вызовов.

Я придумал пока только три варианта реализации- ни один мне не нравится:

в случае неудачи вернуть False или None и уже при вызове функции разобраться с выдачей сообщения.

 def MyFunction():
     # ...
     result = someCalculation()
     # ...
     if result == SOMTHING_UNFIT:
         return False
     else:
         return result
 # ...
 result = MyFunction()
 if result == False:
     print 'Вычисление закончено. Результат не получен.'
 else:
     DoSomething(result)

в случае неудачи выбросить исключение и поймать его, там где нужно

 def MyFunction():
     # ...
     result = someCalculation()
     # ...
     if result == SOMTHING_UNFIT:
         raise MyException('Вычисление закончено. Результат не получен.')
     else:
         return result
 # ...
 try:
     result = MyFunction()
 except MyException as e:
     print(e.args)

 DoSomething(result)

Вернуть словарь, с несолькоми полями

 def MyFunction():
     # ...
     result = someCalculation()
     # ...
     if result == SOMTHING_UNFIT:
         return {
             'fit': False,
             'message': 'Вычисление закончено. Результат не получен.',
             'result': None,
         }
     else:
         return {
             'fit': True,
             'message': None,
             'result': result,
         }
 # ...
 result_dict = MyFunction()

 if result_dict['fit'] == False
     print(result_dict['message'])
 else:
     DoSomething(result_dict['result'])

Чем мне не нравятся эти решения:

возвращаемое значени используется в двух целях — как выдача результата и как индикатор успешности выполнения вычисления. мне кажется, что это неправильно.
выдается куча сообщений, но на самом деле это не исключения, или ошибки — это штатный вариант иногда результат можно вычислить, а иногда нет…
сильно громоздко, и одни поля не используются в одном случае, а другие в другом

Вопросы:

Оптимальный вариант реализации, как это обычно делается (шаблон проектирования?)
есть ли какой-нибудь механизм передать сообщение наверх напрямую (сквозь цепочки вызовов функций, циклы) — типа исключения, но без сообшений об ошибках… вроде какой-нибудь GOTO, аспект, декоратор, DI контейнер, mixin? магия?

задан 1 дек 2021 в 22:15

По-моему вариант с возвратом None самый нормальный если вы считаете, что это не исключительная ситуация. Если это исключительная ситуация — тогда надо выбрасывать исключение (Exception).

Значение None — необычное значение, которое не должно возвращаться в нормальном случае.
Кроме того, возвращаемое значение легко проверить на None:

res = func(...)

if res is None:
    ...

В зависимости от необходимого поведения, можно добавить logging и печатать предупреждения (warning).

ответ дан 1 дек 2021 в 23:00

Традиционно, для решения проблемы с возвратом при ошибке, в Python используется простой приём: функция возвращает 2 значения — результат своей работы и признак наличия ошибки. Как то так:

if .... :
    # Всё хорошо
    return result, False
else:
    return None, True

А в вызывающей программе пишите:

(x, error) = MyFunction(...)
if error:
    ....

ответ дан 2 дек 2021 в 2:58

SergeySergey

12.8k12 серебряных знаков25 бронзовых знаков

На самом деле все варианты вполне нормальные. Про нюансы других вариантов написали уже в других ответах, а я хочу сказать про исключения. Вас ведь никто не заставляет печатать пойманное исключение MyException. Вы можете просто пробрасывать именно это исключение насколько вам нужно наверх, и только где-то наверху что-то вывести, да и то, если вам это нужно. Это просто механизм возврата управления выше по цепочке, если возникла такая необходимость.

ответ дан 2 дек 2021 в 4:10

CrazyElfCrazyElf

62.2k5 золотых знаков19 серебряных знаков47 бронзовых знаков

Источник

На следующем рисунке показана область ошибки

На следующем рисунке показана область, связанная с ошибками.

Давайте переведем это неправильное значение

Оригинал: предупреждение C4508: «main»: функция должна возвращать значение; «void» тип возврата предполагается
Перевод: Предупреждение C4508: «main»: функция должна возвращать значение, «void» тип возврата

Мы можем заметить, что это не ошибка, а только предупреждение, поэтому мы можем на самом деле игнорировать ее, но если нам нужно ее изменить, как ее следует изменить?

Это означает, что основная функция не возвращает значение, поэтому нам нужно только изменитьконец основной функцииВозврат добавленной стоимостиreturn 0Вот и все.

Проблема была решена здесь。

Но одно не ясно:
void main () не требует возвращаемого значения, и мы также знаем, что void main на самом деле является нестандартным способом записи, правильный способ записи должен быть
int main (void) или int main (int argc, char * argv [])
Мы заменяем int main (int argc, char * argv []) на другие формы:
1. Используйте void main для замены, когда мы используем void main для замены, программа не сообщает об ошибке;
2. Вместо этого используйте int main (void), программа сообщает об ошибке.

Таким образом, мы заключаем, что только void main может возвращаться без значения, а другие формы должны возвращаться со значением.

Источник

Моя проблема довольно проста, но я не понимаю причины ее возникновения, и даже после обширных исследований не появилось ни одного подобного сообщения, поэтому вот оно:

У меня есть следующая перегрузка оператора:

template <class T, size_t size>
inline Vector<T, size> operator + (Vector<T, size> &a, Vector<T, size> &b) {
Vector<T, size> result;
for (auto i = 0; i < size; ++i) {
result[i] = a[i] + b[i];
}
return result;
}

Очевидно, что существует только один путь к коду, и этот путь также возвращает значение, но при компиляции в Visual Studio 2013 я получаю ошибку C4716, утверждающую, что функция, созданная компилятором, «должна возвращать значение». Я получаю эту ошибку для всех экземпляров, которые я пробовал до сих пор. Я также получаю эту ошибку для всех других операторов перегрузки в том же заголовке, все из которых структурированы аналогично приведенному выше фрагменту.
Я что-то упускаю здесь очевидное?

РЕДАКТИРОВАТЬ: Это шаблонное определение векторного класса:

template <class T, size_t size>
struct Vector {
explicit Vector(T value = static_cast<T>(0)) {
for (auto i = 0; i < size; ++i) {
_data[i] = value;
}
}
explicit Vector(const Vector &other) {
for (auto i = 0; i < size; ++i) {
_data[i] = other._data[i];
}
}
explicit Vector(T values[size]) {
for (auto i = 0; i < size; ++i) {
_data[i] = values[i];
}
}
T & operator = (const Vector &other) {
for (auto i = 0; i < size; ++i) {
_data[i] = other._data[i];
}
return *this;
}

T & operator [] (size_t index) {
return _data[index];
}

T _data[size];
};

Решение

Проблема была решена для меня, сделав конструктор копирования Vector неявным.

Чтобы описать, как я пришел к такому выводу, я пошел и специализировал операторную функцию для Vector:

template <>
inline Vector<int, 1> operator + (Vector<int, 1> &a, Vector<int, 1> &b) {
Vector<int, 1> result;
return result;
}

В Visual Studio возникла ошибка, в которой говорится, что для возвращаемого значения не существует подходящего конструктора копирования, что было устранено путем удаления явного ключевого слова из конструктора копирования.
Это было бы очевидно для меня, если бы я правильно понял, как работают явные конструкторы копирования.

Другие решения

Источник

Ошибка функция должна возвращать значение

Обработка ошибок в функциях

Обработка ошибки в функции

Передача ошибок вызывающей функции

Фатальные ошибки

Исключения

Теги

Решение

Другие решения

А вот еще интересные материалы: