একটি পূর্ণসংখ্যার ব্যাপ্তি উপস্থাপনের জন্য কি সি # টাইপ রয়েছে?

Question

আমার একটি পূর্ণসংখ্যার ব্যাপ্তি সঞ্চয় করতে হবে। C # 4.0 এ কি এর জন্য বিদ্যমান কোন ধরণ রয়েছে?

অবশ্যই, আমি নিজের শ্রেণি int Fromএবং int Toবৈশিষ্ট্যগুলি সহ লিখতে পারি এবং এটি নিশ্চিত করার জন্য যথাযথ যুক্তি তৈরি করতে পারি From <= To। তবে যদি কোনও প্রকার ইতিমধ্যে বিদ্যমান থাকে তবে আমি অবশ্যই এটি ব্যবহার করব।

Comments

আমি মনে করি গৃহীত উত্তরটি পরিবর্তন করা উচিত। @ আরএসেনার উত্তরটি Enumerable.Rangeহ'ল, আমি যা দেখেছি, সেখান থেকে সি # 3.0 এ রেঞ্জগুলি বাস্তবায়নের উপায় to এবং সি # 3.0 2007 সাল থেকে প্রায় তাই এখন এই মুহুর্তে 9 বছর।

— এহতেশ চৌধুরী

@ এহতেশচৌধুরি ওপিতে বিচ্ছিন্ন মানগুলি পরিচালনা করার বিষয়ে, এমনকি এমন এক মিনিট এবং সর্বাধিকের জন্য এই ধরণের বৈধতা সম্পর্কেও কিছু উল্লেখ করা হয়নি, যা এটি Enumerable.Rangeঅর্জন করে। ওপি কেবলমাত্র একটি বিদ্যমান ডাটা স্ট্রাকচারের সন্ধান করছিল যা অন্তরগুলিকে পরিচালনা করে যা নিম্ন এবং উপরের গণ্ডির বৈশিষ্ট্যযুক্ত থাকতে পারে এবং আরও কিছু নয় (নির্দিষ্ট আচরণগুলি কার্যকর করার পদ্ধতি ছাড়াও)।

— সানি প্যাটেল

@ এহতেশচৌধুরি আমি "ভলিউমযুক্ত ব্যবহার করবেন না। এক জোড়া ন্যূনতম / সর্বাধিক মানকে ধরে রাখার সহজ সমস্যাটি সমাধান করার এটি একটি জঘন্য উপায়। এনামিউরেবল.ম্যাক্সের প্রতিটি কল (আইউনামেবল <মিন্ট>) (বা এনিউরেবল.মিন) সীমাটি নির্ধারণের জন্য পুরো ব্যাপ্তিটির পুনরাবৃত্তি করে। অন্যরা যেমন বলেছে, এটি অনেকগুলি পুনরাবৃত্তি হতে পারে : আমরা এখানে মাইক্রো পারফরম্যান্সের টিউনিংয়ের কথা বলছি না, আমরা পঙ্গু আস্তে কথা বলছি। এই জাতীয় প্রোগ্রামিং এর কারণ। নেট পারফরম্যান্সের জন্য একটি (অন্যায়ভাবে) খারাপ নাম পায়! গৃহীত উত্তর এবং অনুরূপ উত্তরগুলি একমাত্র ব্যবহারিক সমাধান।

— ড্যানিয়েল স্কট

এটা সঙ্গত. Enumerable.Range(1,1000000) বনাম একটি রেঞ্জ ডেটাটাইপ (1,1000000) এর জন্য আরও অনেক বেশি স্থান গ্রহণ করবে। আমি প্রথমবার প্রশ্নটি জিজ্ঞাসা করার সময় ভুল পড়েছি এবং ভেবেছিলাম এটি জিজ্ঞাসা করা হয়েছিলEnumerable.Range

— এহতেশ চৌধুরী

@ এহতেশচৌধুরি গণনাযোগ্য an কমপক্ষে আপনি টোললিস্ট () পদ্ধতিতে কল করুন তবে রেঞ্জ কমপক্ষে 1,1000000 নেবে না।

— লুই

Answer 1

আমি আমার নিজের রোল করা ভাল। কিছু লোক Tupleগুলি s বা Pointগুলি ব্যবহার করে তবে শেষ পর্যন্ত আপনি চান যে আপনি Rangeবিস্তৃত হন এবং কিছু সম্পর্কিত পদ্ধতিগুলি সরবরাহ করে যা একটি এর সাথে সম্পর্কিত Range। জেনেরিক (আপনার যদি বিভিন্ন শ্রেণীর Double, বা কিছু কাস্টম শ্রেণীর একটি রেঞ্জের প্রয়োজন হয় তবে কী হবে ?) উদাহরণস্বরূপ:

/// <summary>The Range class.</summary>
/// <typeparam name="T">Generic parameter.</typeparam>
public class Range<T> where T : IComparable<T>
{
    /// <summary>Minimum value of the range.</summary>
    public T Minimum { get; set; }

    /// <summary>Maximum value of the range.</summary>
    public T Maximum { get; set; }

    /// <summary>Presents the Range in readable format.</summary>
    /// <returns>String representation of the Range</returns>
    public override string ToString()
    {
        return string.Format("[{0} - {1}]", this.Minimum, this.Maximum);
    }

    /// <summary>Determines if the range is valid.</summary>
    /// <returns>True if range is valid, else false</returns>
    public bool IsValid()
    {
        return this.Minimum.CompareTo(this.Maximum) <= 0;
    }

    /// <summary>Determines if the provided value is inside the range.</summary>
    /// <param name="value">The value to test</param>
    /// <returns>True if the value is inside Range, else false</returns>
    public bool ContainsValue(T value)
    {
        return (this.Minimum.CompareTo(value) <= 0) && (value.CompareTo(this.Maximum) <= 0);
    }

    /// <summary>Determines if this Range is inside the bounds of another range.</summary>
    /// <param name="Range">The parent range to test on</param>
    /// <returns>True if range is inclusive, else false</returns>
    public bool IsInsideRange(Range<T> range)
    {
        return this.IsValid() && range.IsValid() && range.ContainsValue(this.Minimum) && range.ContainsValue(this.Maximum);
    }

    /// <summary>Determines if another range is inside the bounds of this range.</summary>
    /// <param name="Range">The child range to test</param>
    /// <returns>True if range is inside, else false</returns>
    public bool ContainsRange(Range<T> range)
    {
        return this.IsValid() && range.IsValid() && this.ContainsValue(range.Minimum) && this.ContainsValue(range.Maximum);
    }
}

Comments

সেই সময়, আমি নিশ্চিত ছিলাম না যে IComparableঅপারেটরের ওভারলোডের গ্যারান্টি দেবে। আমি একটি CompareToপদ্ধতির গ্যারান্টিযুক্ত , তাই সেই ব্যবহার।

— drharris

: আউট আমি সক্রিয় সঠিকভাবে করলে যে ছিল stackoverflow.com/questions/5101378/...

— drharris

structপরিবর্তে ভাল হতে পারে class?

— xmedeko

@ ওহে মানুষ খালি হাতিয়ার ডকুমেন্টেশনের জ্ঞানকে ঠকাবে না। :)

— drharris

খুব সহায়ক, ধন্যবাদ! এমন কোনও কনস্ট্রাক্টর যুক্ত করবেন না যা আপনাকে অবিলম্বে এটি আরম্ভ করার অনুমতি দেয়? public Range(T min, T max) { Minimum = min; Maximum = max; }

— NateJC

Answer 2

আমি লিখেছিলাম কেবল একটি ছোট্ট ক্লাস যা কারও পক্ষে সহায়ক হতে পারে:

    public class Range
    {
        public static List<int> range(int a, int b)
        {
            List<int> result = new List<int>();

            for(int i = a; i <= b; i++)
            {
                result.Add(i);
            }

            return result;
        }

        public static int[] Understand(string input)
        {
            return understand(input).ToArray();
        }

        public static List<int> understand(string input)
        {
            List<int> result = new List<int>();
            string[] lines = input.Split(new char[] {';', ','});

            foreach (string line in lines)
            {
                try
                {
                    int temp = Int32.Parse(line);
                    result.Add(temp);
                }
                catch
                {
                    string[] temp = line.Split(new char[] { '-' });
                    int a = Int32.Parse(temp[0]);
                    int b = Int32.Parse(temp[1]);
                    result.AddRange(range(a, b).AsEnumerable());
                }
            }

            return result;
        }
    }

তারপরে আপনি কেবল কল করুন:

Range.understand("1,5-9,14;16,17;20-24")

এবং ফলাফলটি দেখে মনে হচ্ছে:

List<int>
    [0]: 1
    [1]: 5
    [2]: 6
    [3]: 7
    [4]: 8
    [5]: 9
    [6]: 14
    [7]: 16
    [8]: 17
    [9]: 20
    [10]: 21
    [11]: 22
    [12]: 23
    [13]: 24

Comments

আমি সত্যিই বোঝার ফাংশনটি পছন্দ করি

— ড্রাগনর্ন

যে understandফাংশন দুর্দান্ত। আমি যদি আমাদের কোডটিতে একটি পর্যালোচনাতে এটি দেখে থাকি তবে আমি এটির নামকরণ করার পরামর্শ দেব Setকারণ Range(আমার জন্য) অবিচ্ছিন্ন শোনায়।

— dlw

Answer 3

রেঞ্জ এবং সূচকগুলি সি # 8.0 দিয়ে প্রকাশিত হয়েছে।

আপনি এখন করতে সক্ষম

string[] names =
{
    "Archimedes", "Pythagoras", "Euclid", "Socrates", "Plato"
};
foreach (var name in names[1..4])
{
    yield return name;
}

আরও তথ্যের জন্য https://blogs.msdn.microsoft.com/dotnet/2018/12/05/take-c-8-0- জন্য-a- spin/ দেখুন।

Comments

এটি একটি ভিন্ন ধারণা এবং ওপি চেয়েছে না।

— পেপিতোশ

System.Rangeটাইপ তো গ্রহণ করেন int, যদিও।

— স্নিপস্নিপসনিপ

এটি উল্লেখ করা জরুরী যে এটি কেবলমাত্র নেট কোর 3.0 থেকে উপলব্ধ। এটি নেট ফ্রেমওয়ার্কে অনুপলব্ধ।

— সররাস

Answer 4

এটি আরও idiomatic এবং সহজেই স্বনির্ধারিত করার জন্য @ andrius-naruševičius খুব সহায়ক উত্তরের উপর উন্নতি করা

/// <summary>
/// http://stackoverflow.com/questions/5343006/is-there-a-c-sharp-type-for-representing-an-integer-range
/// </summary>
public class Range
{
    readonly static char[] Separators = {','};

    public static List<int> Explode(int from, int to)
    {
        return Enumerable.Range(from, (to-from)+1).ToList();
    }

    public static List<int> Interpret(string input)
    {
        var result = new List<int>();
        var values = input.Split(Separators);

        string rangePattern = @"(?<range>(?<from>\d+)-(?<to>\d+))";
        var regex = new Regex(rangePattern);

        foreach (string value in values)
        {
            var match = regex.Match(value);
            if (match.Success)
            {
                var from = Parse(match.Groups["from"].Value);
                var to = Parse(match.Groups["to"].Value);
                result.AddRange(Explode(from, to));
            }
            else
            {
                result.Add(Parse(value));
            }
        }

        return result;
    }

    /// <summary>
    /// Split this out to allow custom throw etc
    /// </summary>
    private static int Parse(string value)
    {
        int output;
        var ok = int.TryParse(value, out output);
        if (!ok) throw new FormatException($"Failed to parse '{value}' as an integer");
        return output;
    }
}

এবং পরীক্ষা:

    [Test]
    public void ExplodeRange()
    {
        var output = Range.Explode(5, 9);

        Assert.AreEqual(5, output.Count);
        Assert.AreEqual(5, output[0]);
        Assert.AreEqual(6, output[1]);
        Assert.AreEqual(7, output[2]);
        Assert.AreEqual(8, output[3]);
        Assert.AreEqual(9, output[4]);
    }

    [Test]
    public void ExplodeSingle()
    {
        var output = Range.Explode(1, 1);

        Assert.AreEqual(1, output.Count);
        Assert.AreEqual(1, output[0]);
    }

    [Test]
    public void InterpretSimple()
    {
        var output = Range.Interpret("50");
        Assert.AreEqual(1, output.Count);
        Assert.AreEqual(50, output[0]);
    }

    [Test]
    public void InterpretComplex()
    {
        var output = Range.Interpret("1,5-9,14,16,17,20-24");

        Assert.AreEqual(14, output.Count);
        Assert.AreEqual(1, output[0]);
        Assert.AreEqual(5, output[1]);
        Assert.AreEqual(6, output[2]);
        Assert.AreEqual(7, output[3]);
        Assert.AreEqual(8, output[4]);
        Assert.AreEqual(9, output[5]);
        Assert.AreEqual(14, output[6]);
        Assert.AreEqual(16, output[7]);
        Assert.AreEqual(17, output[8]);
        Assert.AreEqual(20, output[9]);
        Assert.AreEqual(21, output[10]);
        Assert.AreEqual(22, output[11]);
        Assert.AreEqual(23, output[12]);
        Assert.AreEqual(24, output[13]);
    }

    [ExpectedException(typeof (FormatException))]
    [Test]
    public void InterpretBad()
    {
        Range.Interpret("powdered toast man");
    }

Answer 5

এভাবে একটি এক্সটেনশন পদ্ধতি লিখুন

 public static class NumericExtentions
    {
        public static bool InRange(this int value, int from, int to)
        {
            if (value >= from && value <= to)
                return true;
            return false;
        }

        public static bool InRange(this double value, double from, double to)
        {
            if (value >= from && value <= to)
                return true;
            return false;
        }
    }

এবং তারপরে এটি মার্জিতভাবে ব্যবহার করুন

if (age.InRange(18, 39))
{ 
//Logic
}

Comments

কেন if (value >= from && value <= to) return true;এবং না return (value >= from && value <= to)?

— sdgfsdh

Answer 6

@ ডিগ্রিসের উত্তর দ্বারা অনুপ্রাণিত এই বাস্তবায়ন আপনাকে মানগুলি সহ সঠিক গাণিতিক ব্যবধানটি সংজ্ঞায়িত করতে দেয়, এটি অন্তর্ভুক্ত / এক্সক্লুসিভ হতে পারে।

/// <summary>The Interval class.</summary>
/// <typeparam name="T">Generic parameter.</typeparam>
public class Interval<T> : IEquatable<Interval<T>>
    where T : IComparable<T>, IEquatable<T>
{
    public Interval()
    { }

    public Interval(IntervalValue<T> minimum, IntervalValue<T> maximum)
    {
        this.Minimum = minimum;
        this.Maximum = maximum;
    }

    /// <summary>Minimum value of the interval.</summary>
    public IntervalValue<T>? Minimum { get; set; }

    /// <summary>Maximum value of the interval.</summary>
    public IntervalValue<T>? Maximum { get; set; }

    /// <summary>Presents the Interval in readable format.</summary>
    /// <returns>String representation of the Interval</returns>
    public override string ToString()
    {
        var min = this.Minimum;
        var max = this.Maximum;
        var sb = new StringBuilder();

        if (min.HasValue)
            sb.AppendFormat(min.Value.ToString(IntervalNotationPosition.Left));
        else
            sb.Append("(-∞");

        sb.Append(',');

        if (max.HasValue)
            sb.AppendFormat(max.Value.ToString(IntervalNotationPosition.Right));
        else
            sb.Append("∞)");

        var result = sb.ToString();

        return result;
    }

    /// <summary>Determines if the interval is valid.</summary>
    /// <returns>True if interval is valid, else false</returns>
    public bool IsValid()
    {
        var min = this.Minimum;
        var max = this.Maximum;

        if (min.HasValue && max.HasValue)
            return min.Value.Value.CompareTo(max.Value.Value) <= 0;

        return true;
    }

    /// <summary>Determines if the provided value is inside the interval.</summary>
    /// <param name="x">The value to test</param>
    /// <returns>True if the value is inside Interval, else false</returns>
    public bool ContainsValue(T x)
    {
        if (x == null)
            throw new ArgumentNullException(nameof(x));

        var min = this.Minimum;
        var max = this.Maximum;
        var isValid = this.IsValid();

        if (!isValid)
            throw new InvalidOperationException("Interval is not valid.");

        bool result = true; // (-∞,∞)

        if (min.HasValue)
        {
            if (min.Value.Type == IntervalValueType.Exclusive)
                result &= min.Value.Value.CompareTo(x) < 0;
            else if (min.Value.Type == IntervalValueType.Inclusive)
                result &= min.Value.Value.CompareTo(x) <= 0;
            else
                throw new NotSupportedException();
        }

        if (max.HasValue)
        {
            if (max.Value.Type == IntervalValueType.Exclusive)
                result &= max.Value.Value.CompareTo(x) > 0;
            else if (max.Value.Type == IntervalValueType.Inclusive)
                result &= max.Value.Value.CompareTo(x) >= 0;
            else
                throw new NotSupportedException();
        }

        return result;
    }

    public bool Equals(Interval<T> other)
    {
        if (other == null)
            return false;

        if (ReferenceEquals(this, other))
            return true;

        return this.Minimum?.Equals(other.Minimum) == true
            && this.Maximum?.Equals(other.Maximum) == true;
    }

    public override bool Equals(object obj)
    {
        return this.Equals(obj as Interval<T>);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            int hash = (int)2166136261;

            hash = hash * 16777619 ^ this.Minimum?.GetHashCode() ?? 0;
            hash = hash * 16777619 ^ this.Maximum?.GetHashCode() ?? 0;

            return hash;
        }
    }
}

public struct IntervalValue<T> : IEquatable<IntervalValue<T>>
    where T : IComparable<T>, IEquatable<T> //, IFormattable
{
    private readonly T value;
    private readonly IntervalValueType type;

    public IntervalValue(T value, IntervalValueType type)
    {
        if (value == null)
            throw new ArgumentNullException(nameof(value));

        this.value = value;
        this.type = type;
    }

    public T Value
    {
        get { return this.value; }
    }

    public IntervalValueType Type
    {
        get { return this.type; }
    }

    public bool Equals(IntervalValue<T> other)
    {
        return this.value.Equals(other.value)
            && this.type == other.type;
    }

    public override bool Equals(object obj)
    {
        return obj is IntervalValue<T> && this.Equals((IntervalValue<T>)obj);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            int hash = (int)2166136261;

            hash = hash * 16777619 ^ this.value.GetHashCode();
            hash = hash * 16777619 ^ this.type.GetHashCode();

            return hash;
        }
    }

    internal string ToString(IntervalNotationPosition position)
    {
        var notation = this.Type.ToString(position);

        switch (position)
        {
            case IntervalNotationPosition.Left:
                return string.Format("{0}{1}", notation, this.Value);

            case IntervalNotationPosition.Right:
                return string.Format("{0}{1}", this.Value, notation);

            default:
                throw new NotSupportedException();
        }
    }
}

internal static class IntervalValueTypeExtensions
{
    public static string ToString(this IntervalValueType type, IntervalNotationPosition position)
    {
        switch (position)
        {
            case IntervalNotationPosition.Left:
                switch (type)
                {
                    case IntervalValueType.Inclusive: return "[";
                    case IntervalValueType.Exclusive: return "(";

                    default:
                        throw new NotSupportedException();
                }

            case IntervalNotationPosition.Right:
                switch (type)
                {
                    case IntervalValueType.Inclusive: return "]";
                    case IntervalValueType.Exclusive: return ")";

                    default:
                        throw new NotSupportedException();
                }
                break;

            default:
                throw new NotSupportedException();
        }
    }
}

public enum IntervalValueType
{
    Inclusive,
    Exclusive
}

public enum IntervalNotationPosition
{
    Left,
    Right
}

Answer 7

এছাড়াও, এখানে কিছুটা ভিন্ন স্পর্শকাতর তবে কখনও কখনও সীমাগুলি কেবল তাদের উপর পুনরাবৃত্তি করার জন্য দরকারী, কিছুটা অজগরটি করার জন্য এটি প্রচলিত। সেক্ষেত্রে System.Linqনেমস্পেস একটি static IEnumerable<int> Range(Int32, Int32)পদ্ধতি সংজ্ঞায়িত করে , যা স্বাক্ষর হিসাবে বোঝায়,

একটি নির্দিষ্ট ব্যাপ্তির মধ্যে অবিচ্ছেদ্য সংখ্যার ক্রম উত্পন্ন করে

এমএসডিএন-তে ডকুমেন্টেশন এবং উদাহরণগুলি দেখুন

Comments

@ তবে এটি হওয়া উচিত নয় যেহেতু প্রচুর পরিসীমা শুরু এবং গণনা গ্রহণ করে।

— রশিদ

@ রাশিদ মোটামুটি যথেষ্ট তবে আমি সত্যিই এটিকে কোনও সমস্যা মনে করি না। আমি জানি ওপি একটি "ক্লাস সহ int Fromএবং " ক্লাস করার জন্য বলেছিল int Toতবে আমি যথেষ্ট আত্মবিশ্বাসী যে এটি কোনও নির্দিষ্ট প্রয়োজন ছিল না বরং তাদের বিষয়টি চিত্রিত করার জন্য কিছু ছিল। কেউ আগ্রহী জন্য, অবশ্যই, মান countপরামিতি খুব সহজেই নির্ধারিত করা যেতে পারে, মঞ্জুর থাকা ব্যক্তিগণ int Fromএবং int Toভেরিয়েবল ইতিমধ্যে।

— গাবাইক 1

Answer 8

একটি Enumerable.Rangeপদ্ধতি আছে তবে এটি একটিকে গ্রহণ করে startএবং countএর পরামিতি হিসাবে। জন্য এটা কি আপনি চান হিসাবে কাজ করার জন্য startএবং end, endসূত্র হবেend - start + 1

ব্যবহার:

Enumerable.Range(start, end - start + 1).ToList()

Answer 9

যেহেতু আমি সি # তেও অন্তরগুলি অনুপস্থিত ছিলাম, তাই আমি একটি সম্পূর্ণ জেনেরিক ইন্টারভাল ক্লাস প্রয়োগ করেছি যা আরও জটিল ধরণের সাথে অন্তরগুলির যত্ন নিতে পারে যেমন, দু'জনের মধ্যে একটি ব্যবধান DateTimeযা TimeSpanগণনার সময় জড়িত ।

উদাহরণ ব্যবহারের ক্ষেত্রে, যেখানে একটি জিইউআই উপাদান সময় ব্যবধানের প্রতিনিধিত্ব করে:

// Mockup of a GUI element and mouse position.
var timeBar = new { X = 100, Width = 200 };
int mouseX = 180;

// Find out which date on the time bar the mouse is positioned on,
// assuming it represents whole of 2014.
var timeRepresentation = new Interval<int>( timeBar.X, timeBar.X + timeBar.Width );
DateTime start = new DateTime( 2014, 1, 1 );
DateTime end = new DateTime( 2014, 12, 31 );
var thisYear = new Interval<DateTime, TimeSpan>( start, end );
DateTime hoverOver = timeRepresentation.Map( mouseX, thisYear );

// If the user clicks, zoom in to this position.
double zoomLevel = 0.5;
double zoomInAt = thisYear.GetPercentageFor( hoverOver );
Interval<DateTime, TimeSpan> zoomed = thisYear.Scale( zoomLevel, zoomInAt );

// Iterate over the interval, e.g. draw labels.
zoomed.EveryStepOf( TimeSpan.FromDays( 1 ), d => DrawLabel( d ) );

সমর্থিত কার্যকারিতার আরও বিস্তৃত উপস্থাপনার জন্য ইউনিট পরীক্ষাগুলি পরীক্ষা করে দেখুন ।

কভারগুলির নীচে এটি রানটাইমে টাইপ অপারেটর ক্রিয়াকলাপগুলি সংশ্লেষ করতে এক্সপ্রেশন ট্রি ব্যবহার করে , যা ক্যাশেড হয় তাই টাইপটি প্রথম বার শুরু হওয়ার পরে কেবল ব্যয় হয়।

Answer 10

কিভাবে একটি স্ট্রাক্ট সম্পর্কে ?

Comments

আমি কোনও কাঠামো ব্যবহার করব না আপনি যদি না জানতেন যে একবার এবং সর্বদা মানগুলি একবার তাত্ক্ষণিকভাবে পরিবর্তিত হয় না ।

— IAbstract

এটি "ইতিমধ্যে বিদ্যমান" প্রশ্নের উত্তর দেয়। কাঠামোর ধরণটি বিশেষত প্রশ্নাবলীর মতো ধরণের জন্য বিদ্যমান।

— জেমস সামনার্স

স্ট্রাক্ট একটি নিজস্ব এবং নিজস্ব ধরণের নয়। আপনি মূলত বলছেন "যান না নিজের ধরণের তৈরি করুন" - এটি একটি বৈধ উত্তর

— রবার্ট লেভি

প্রথম তিনটি শব্দ "struct টাইপ ...": লিঙ্ক ডকুমেন্টেশন আপনার সাথে দ্বিমত পোষন

— জেমস Sumners

আমি jsumners সাথে একমত হতে ঝোঁক। একটি স্ট্রাক্ট এটি করার একটি সহজ এবং সোজা-এগিয়ে উপায়, এবং এটি 2 পৃষ্ঠাগুলির কোড তৈরি করে না যা এতো সাধারণ সমস্যার জন্য পরে বজায় রাখতে হয়। আপনি একই জিনিসটির জন্য একটি জুড়ি <...> ব্যবহার করতে পারেন। মাইক্রোসফ্ট বিভিন্ন জায়গায় স্থাবর স্ট্রাইক সম্পর্কে তাদের নিজস্ব "নিয়ম" ভঙ্গ করে break

— টম