Member Avatar for massivefermion

Hi pals
I have three qestions
1-Is it possible to overload {} operator?
2-What is the benefit of using function objects other than functions?
3-How can i access CPU serial number and such a things?

  • 4 Contributors
  • 3 Replies
  • 123 Views
  • 11 Hours Discussion Span
  • Latest Post Latest Post by MosaicFuneral

Dani AI

Generated

Brief, practical answers tied to the existing replies.

For the {} question (Q1): braces are syntax for list- and aggregate-initialization, not a user-overloadable operator. You cannot define operator{}. To make a type accept brace syntax, provide appropriate constructors (including a constructor taking std::initializer_list) or make it an aggregate. Example:

struct Bag {
    Bag(std::initializer_list<int> il) {
        for (int v : il) data.push_back(v);
    }
    std::vector<int> data;
};

Bag b{1, 2, 3}; // uses initializer_list constructor

See cppreference on std::initializer_list for the exact rules: https://en.cppreference.com/w/cpp/utility/initializer_list

For function objects vs free functions (Q2): is right that objects carry state. Practical differences: functors (classes with operator()) let you store configuration, are often inlined when used as template parameters (zero-overhead), and compose well with STL algorithms. Lambdas are just syntax sugar producing function objects that can capture locals. std::function gives type erasure but adds runtime cost; prefer templates (callable parameters) for hot paths. Quick illustration:

struct Mul { int factor; int operator()(int x) const { return x * factor; } };
auto lam = [f=3](int x){ return x * f; };

References: lambdas and std::function docs: https://en.cppreference.com/w/cpp/language/lambda and https://en.cppreference.com/w/cpp/utility/functional/function

For CPU serials/identifiers (Q3): this is the murkiest area. As noted, a true processor serial number existed historically (Pentium III); modern CPUs do not expose a universal, guaranteed hardware serial via CPUID for privacy reasons. ’s WMI approach reads firmware/OS-provided fields (e.g., Win32_Processor::ProcessorId), which may exist on some systems but is not a guaranteed, immutable CPU hardware serial. If a stable machine identity is required, prefer OS/firmware-provided UUIDs or TPM-backed identifiers rather than assuming a per-CPU serial. See CPUID overview and WMI docs for details: https://en.wikipedia.org/wiki/CPUID and https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/win32-processor

These points expand the replies already posted and give practical, modern guidance.

Recommended Answers

All 3 Replies

Member Avatar for ArkM

1. Don't worry: {} is not an operator.
2. An object has a state so you can incapsulate essential context info for future calls.
3, No such thing as a CPU serial number (CPU ID) in modern Intel processors. To get other CPU parameters: see Intel Architecture Software Developer's manual (try to search in INET)...

Member Avatar for jen140

3 arkm , i dont think you are right.

string cpuInfo = string.Empty;
            ManagementClass mc = new ManagementClass("win32_processor");
            ManagementObjectCollection moc = mc.GetInstances();

            foreach (ManagementObject mo in moc)
            {
                if (cpuInfo == "")
                {
                    //Get only the first CPU's ID
                    cpuInfo = mo.Properties["processorID"].Value.ToString();
                    break;
                }
            }

With the source code above you can find the processors id .
Btw, dont forget to include "using System.Management;" .
And "such stuff" could be found there too.

Member Avatar for MosaicFuneral

You can only get the serial on the PIII processors: Intel CPUID manual, goto page 29.

If you want to learn about the CPUID function read the AMD one:

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.