C / C++ / MFC

int number = 10;
std::vector vec = { 1, 2, 3 };
for (int value : vec)
{
    std::cout << number + value << std::endl;
}

Quote:

Is there a way to add all the elements of a vector to an integer sequentially?

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;


void dump (vector<int> v)
{
  for (auto x :v )
    cout << x << " ";
  cout << "\n";
}

int main()
{

  { // method 1: access items by indices
    vector<int> v{1,2,3};

    int c = 4;

    for (size_t n = 0; n<v.size(); ++n)
    {
      v[n] += c;
    }

    cout << "method 1: ";
    dump(v);
  }

  { // method 2: access items with ranged for loop
    vector<int> v{1,2,3};

    int c = 4;

    for (auto & x : v)
    {
      x += c;
    }

    cout << "method 2: ";
    dump(v);
  }


  { // method 3: use 'transform' of the algorithm library
    vector<int> v{1,2,3};

    int c = 4;

    transform(v.begin(), v.end(), v.begin(), [=](int  x){ return x+c; });

    cout << "method 3: ";
    dump(v);
  }
}

Quote:

As a side note, is there a way to add a repeating number to an integer to infinity?

#include <iostream>
using namespace std;


int main()
{
  int i = 1;
  int last_i;
  int c = 4;
  for (;;)
  {
    last_i = i;
    i += c;
    if ( i < last_i)
      break;
  }

  cout <<  "unfortunately, (" << last_i << "+" << c << ") makes " <<  i;
}

1. In VS menu Project -> Add New Item ... ->
2. In "Add New Item" dialog select MFC in the treeview left, and then choose the "MFC Class From Typelib" and press the Add button
3. In the "Add Class From Typelib" dialog choose the source of interface (registry or file), type libraries and then all the needed interfaces.
4. then press OK

using System.Diagnostics;
using System.Runtime.InteropServices;

namespace CsJobObjectSandbox
{
    internal class Program
    {
        [StructLayout(LayoutKind.Explicit, Size = 8)]
        public struct JobObject_CPU_Rate_Control_Information
        {
            [FieldOffset(0)]
            public uint ControlFlags;

            [FieldOffset(4)]
            public uint CpuRate;
            [FieldOffset(4)]
            public uint Weight;

            [FieldOffset(4)]
            public ushort MinRate;
            [FieldOffset(6)]
            public ushort MaxRate;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct SECURITY_ATTRIBUTES
        {
            public int nLength;
            public IntPtr lpSecurityDescriptor;
            public int bInheritHandle;
        }

        public enum JobObject_Info_Class
        {
            BasicLimitInformation = 2,
            BasicUiRestrictions = 4,
            SecurityLimitInformation = 5,
            EndOfJobItmeInformation = 6,
            AssociateCompletionPortInformation = 7,
            ExtendedLimitInformation = 9,
            GroupInformation = 11,
            NoticiationLimitInformation = 12,
            GroupInformationEx = 14,
            CpuRateControlInformation = 15,
            NetRateControlinformation = 32,
            NotificationLimitInformation = 33,
            LimitViolationInformation2 = 34
        }

        private const uint JOBOBJECT_CPU_RATE_CONTROL_ENABLE = 0x1;
        private const uint JOBOBJECT_CPU_RATE_CONTROL_WEIGHT_BASED = 0x2;
        private const uint JOBOBJECT_CPU_RATE_CONTROL_HARD_CAP = 0x4;
        private const uint JOBOBJECT_CPU_RATE_CONTROL_NOTIFY = 0x8;
        private const uint JOBOBJECT_CPU_RATE_CONTROL_MIN_MAX_RATE = 0x10;

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        static extern IntPtr CreateJobObject([In] ref SECURITY_ATTRIBUTES lpJobAttributes, string lpName);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        static extern bool SetInformationJobObject([In] IntPtr hJob, [In] JobObject_Info_Class jobObjectInfoClass, IntPtr lpJobObjectInfo, int cbJobObjectInfoLength);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        static extern IntPtr AssignProcessToJobObject([In] IntPtr hJob, [In] IntPtr hprocess);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
        static extern bool CloseHandle([In] IntPtr hObject);

        
        static void Main(string[] args)
        {
            // Setup security for the job object. In this case, use the defaults;
            SECURITY_ATTRIBUTES attributes = new();
            attributes.nLength = Marshal.SizeOf(attributes);
            attributes.lpSecurityDescriptor = IntPtr.Zero;
            attributes.bInheritHandle = 0;

            // Create a new job object and set it up for limiting CPU usage to 20%.
            IntPtr jobHandle = CreateJobObject(ref attributes, "SandboxJobObject");
            JobObject_CPU_Rate_Control_Information cpuLimitInfo = new()
            {
                ControlFlags = JOBOBJECT_CPU_RATE_CONTROL_ENABLE | JOBOBJECT_CPU_RATE_CONTROL_HARD_CAP,
                CpuRate = 2000
            };

            // Copy the managed structure we used for setup to a block of unmanaged memory.
            int size = Marshal.SizeOf(typeof(JobObject_CPU_Rate_Control_Information));
            IntPtr infoPointer = Marshal.AllocHGlobal(size);
            Marshal.StructureToPtr(cpuLimitInfo, infoPointer, false);

            // Make the call to set the job object to limit CPU usage...
            bool result = SetInformationJobObject(jobHandle, JobObject_Info_Class.CpuRateControlInformation, infoPointer, size);

            // Did it work?
            if (result)
            {
                // Yep! free the unmanaged block of memory. We don't need it anymore.
                Marshal.FreeHGlobal(infoPointer);

                // Grab the process handle for this process.
                IntPtr processHandle = Process.GetCurrentProcess().Handle;

                // Assign this process to use the job object we created.
                _ = AssignProcessToJobObject(jobHandle, processHandle);

                // Go do some work to test if this worked!
                Task task = TestMethodAsync();
                task.Wait();
            }

            // Oh, when we're done with the job object, make sure to free it!
            CloseHandle(jobHandle);
        }

        // Some long running work that uses all avaialable cores.
        static Task TestMethodAsync()
        {
            return Task.Factory.StartNew(() =>
            {
                long y = 0;

                Parallel.For((long)0, (long)10000000000, (x) =>
                {
                    y = x++ * 2;
                });
            });
        }
    }
}