Optoelectronic devices: Introduction

Summary

The script discusses the concept and importance of functions in programming. It explains that functions are distinct parts of a program, emphasizing their independence from other functions. The main function, 'main', is highlighted as the starting point for program execution, with duties potentially delegated to other functions. Parameters, return types, and the sequence of operations within functions are covered, including the use of loops and conditionals to control flow. The script uses the 'power' function as an example to illustrate function calls, execution, and the significance of argument order. It also touches on the function prototype's role in defining function structure for the compiler, and the practical application of functions like 'printf' and 'scanf'.

Takeaways

• 📚 The script discusses the concept and importance of functions in programming, emphasizing their role as fundamental building blocks in a program.
• 🔍 It clarifies that a function should be independent and not part of another function, highlighting the uniqueness of each function within a program.
• 👀 The video introduces the 'main' function as the starting point of any C program, which is essential for understanding program execution flow.
• 🔑 The script explains the function template, including function name, argument declarations, return type, and the body of the function where local declarations can be made.
• 📐 It demonstrates the use of functions with parameters, such as 'power' function, to perform calculations and return results, showcasing how functions can be called with arguments.
• 🔄 The concept of control flow within a program is explored, showing how execution moves from the 'main' function to other functions and back, including the use of loops and conditionals.
• 📝 The script mentions the importance of understanding the order of arguments passed to functions and the potential confusion that can arise from incorrect order, as illustrated with the 'power' function.
• 🛠️ The role of function prototypes in a program is highlighted, explaining how they provide a blueprint for the function's implementation, including the number and types of parameters and the return type.
• 🔍 The necessity for compilers to check function prototypes for consistency with the actual function implementation is discussed, underlining the importance of correct function declaration.
• 📈 An example of using the 'power' function within a loop is given, illustrating how functions can be integrated into larger program structures and control flows.
• 🖥️ The transcript concludes with a practical example involving loops and function calls, demonstrating the application of concepts discussed throughout the script in a programming context.

Q & A

What is the basic concept of a function in programming?

A function is essentially a block of code designed to perform a specific task within a program. It is a fundamental part of programming that helps in organizing and reusing code effectively.

Why is it important for a function to be independent of other functions?

A function should be independent to ensure modularity and reusability. This means it should not rely on or interfere with other functions' internal workings, promoting cleaner and more maintainable code.

What is the purpose of the 'main' function in a program?

The 'main' function serves as the entry point of a program. Execution of the program begins with the 'main' function, which can then call other functions as needed.

How does the delegation of duties within a program work?

Delegation of duties involves the 'main' function passing control to other functions when necessary. This allows for specific tasks to be handled by specialized functions, which then return control and results back to the 'main' function or other parts of the program.

What is the significance of parameters in a function call?

Parameters are used to pass values into a function, allowing the function to operate on different data each time it is called. They are essential for making functions versatile and dynamic.

Can you explain the concept of 'return' in functions?

The 'return' statement is used in functions to send values back to the caller. It can be used to output the result of a computation or pass data back to the part of the program that invoked the function.

What is the role of the 'printf' function in programming?

The 'printf' function is used for formatted output. It allows programmers to print variables and other data to the console or screen in a specified format.

How does the order of arguments in a function call affect the outcome?

The order of arguments is crucial as it must match the order of parameters defined in the function. Incorrect ordering can lead to incorrect operations and results within the function.

What is a function prototype and why is it important?

A function prototype declares the function's name, return type, and the types and order of its parameters. It is important because it informs the compiler about the function's signature, allowing for type checking and ensuring the correct use of the function.

Can a function call within a program affect the control flow?

Yes, a function call can alter the control flow by transferring execution to the called function. Upon completion, control is returned to the point from which the function was called, potentially altering the sequence of execution.

What is the significance of the 'return' type in a function?

The 'return' type specifies the kind of value a function will return. It is important for the calling code to know what type of data to expect from the function, enabling proper handling of the returned value.

Outlines

00:00

📚 Introduction to Functions

The script begins with an introduction to the concept of functions in programming. It explains that functions are fundamental components of a program and emphasizes the importance of understanding how they operate independently from other functions. The main function, 'main', is highlighted as the starting point of any program, and the necessity of delegating tasks within the main function to other functions is discussed. The script also touches on the idea that functions should not be part of another function, and the importance of parameter passing within functions is introduced.

05:01

🔍 Deeper Dive into Function Mechanics

This paragraph delves deeper into the mechanics of functions, discussing their purpose and how they are used within a program. It covers the function template, including the function name, argument declarations, and return type. The concept of arguments is explored, explaining their role as inputs to functions and the importance of their order and type. The paragraph also introduces the idea of return expressions and how functions can return values to the caller. The summary also touches on the notion of function prototypes and their significance in helping compilers understand function structure.

10:01

🛠 Understanding Function Prototypes and Calls

The script continues with an explanation of function prototypes, which are essential for compilers to check the correct usage of functions. It discusses how prototypes specify the number and types of parameters a function expects and its return type. The importance of function calls, or invocations, is highlighted, showing how control flow is transferred to the function and then back to the caller upon completion. The paragraph also introduces the concept of control flow within programs, starting from the main function and branching out to other functions as needed.

15:03

🔢 Exploring the Power Function and Control Flow

The script presents a specific example of a power function and explains how it is defined and used within a program. It discusses the process of calculating the power of a number and how the result is returned and printed to the screen. The paragraph also illustrates the control flow within the main function, showing how variables are declared, how function calls are made, and how the program progresses from one line to the next, including the use of loops and conditional statements.

20:07

🔄 Loops and Function Calls in Action

This paragraph discusses the use of loops in conjunction with function calls. It describes how the power function is used within a loop to perform calculations iteratively and how the results are printed to the screen using printf. The explanation includes the process of incrementing loop variables and checking conditions at the end of each loop iteration. The paragraph emphasizes the complexity of control flow when combining loops with function calls and the importance of understanding the sequence of operations.

27:12

📝 Conclusion and Final Thoughts on Functions

The final paragraph wraps up the discussion on functions by summarizing the key points covered in the script. It reiterates the importance of understanding functions, their independence, and their role in breaking down complex tasks into manageable sub-tasks. The paragraph also highlights the significance of main functions, parameter passing, and return values. It concludes with a note on the practical use of functions like printf and scanf, and hints at further exploration of these concepts in future lessons.

Keywords

💡Function

In the context of the video, a 'Function' is a fundamental concept in programming, representing a block of code designed to perform a specific task. It is crucial for understanding the video's theme as it explains how functions operate within a program. For example, the script mentions 'మెయిన్' (main) function, which is the entry point of a program, and 'పవర్' (power) function, which is used to calculate exponentiation.

💡Control Flow

Control Flow refers to the order in which individual statements, instructions, or function calls of an imperative program are executed. It is key to understanding the script's narrative as it describes how execution moves from the main function to other functions and back. The script illustrates this with the use of functions and loops, showing how control is passed and returned.

💡Parameters

Parameters are the variables listed in a function definition that are used to pass arguments into the function. They are essential to the video's theme as they enable functions to receive input. The script uses terms like 'ఆర్గుమెంట్స్' (arguments) to illustrate how values are passed to functions like 'పవర్' (power), affecting the function's operation.

💡Return Value

A 'Return Value' is the result that a function outputs. It is a fundamental part of the video's content as it discusses how functions like 'printf' and 'power' produce output. The script mentions 'రిటర్న్' (return) to explain how functions provide results back to the caller.

💡Prototype

A 'Prototype' in programming defines the interface for a function by specifying its name, the type and order of its parameters, and its return type. The video script touches on this concept when discussing how functions are declared and used within a program, emphasizing the importance of matching function calls with their prototypes.

💡Loop

A 'Loop' is a programming construct that allows code to be executed repeatedly based on a condition. The script discusses loops in the context of control flow, showing how they can be used to repeat function calls and other operations. The example of using a loop to print powers of numbers illustrates this concept.

💡Control Structures

Control Structures determine the order in which statements are executed in a program. The video script explains various control structures like loops and conditional statements, which are central to the theme of program execution and function interaction.

💡Arguments

Arguments are the actual values that are passed to a function when it is called. The script uses the term 'ఆర్గుమెంట్స్' to explain how data is provided to functions, affecting their behavior and the computation that takes place within them.

💡Declaration

A 'Declaration' in programming is the act of announcing a variable or function's existence and type to the compiler. The video script refers to variable and function declarations, which is essential for setting up the environment for execution.

💡Execution

Execution refers to the running of a program or part of a program. The video script discusses the execution of the main function and other functions, highlighting the process from start to finish, including the calling of functions and the use of loops.

💡printf

The 'printf' function is a standard library function in C used for formatted output to the console. The script mentions 'printf' as an example of a function that is called with parameters to print values to the screen, demonstrating its use in the context of the program's output.

Highlights

Introduction to the concept of functions in programming and their basic components.

Explanation of how functions operate independently and do not form part of another function.

Discussion on the importance of the 'main' function and its role in initiating program execution.

The necessity of understanding the sequence of function calls and control flow within a program.

Clarification on the use of parameters within functions and their impact on the program's logic.

The role of return values in functions and how they contribute to the program's output.

The significance of function prototypes in defining the structure and behavior of functions.

Explanation of how the order of arguments in function calls affects the outcome.

The importance of declaring variables within the scope of functions.

The concept of recursion and how functions can call themselves within the program.

The impact of control structures like loops and conditional statements on the flow of a program.

The use of 'printf' as a function to display output on the screen.

The practical application of functions in solving mathematical problems, such as calculating powers.

The process of function definition and invocation within the 'main' function.

The concept of passing parameters by value and how it affects the function's execution.

The importance of understanding the end of a function's execution and the return to the caller.

The explanation of how to handle multiple tasks within a program using functions.

Transcripts

మునుపటి మాడ్యూల్‌లో, ఫంక్షన్‌ల యొక్క

ప్రాథమిక అంశాలు మరియు ఇది ఎలా బాగుంది

మరియు అది ఎలా చదవగలిగేలా చేస్తుంది మొదలైనవాటిని

చూశాము.

ఈ మాడ్యూల్‌లో, మేము ఈ ఫంక్షన్‌ల భావన

మరియు మరిన్ని వివరాలను పరిశీలిస్తాము.

ఫంక్షన్ అంటే ఏమిటి?

ఫంక్షన్ తప్పనిసరిగా మీ ప్రోగ్రామ్‌లో

ఒక భాగం.

కాబట్టి, మీరు జాగ్రత్తగా ఉండవలసిన ఒక విషయం

ఏమిటంటే, ఇది ఏ ఇతర ఫంక్షన్‌లో భాగం

కాకూడదు.

ఒక ఫంక్షన్ ఏ ఇతర ఫంక్షన్‌లో భాగం

కాకూడదు.

మునుపటి మాడ్యూల్‌లో మనం మెయిన్ అనే ఫంక్షన్

ఉందని చూశాము, అది కాలర్ మరియు పవర్

అనే ఫంక్షన్ ఉంది, అది కాళీ.

మేము పవర్ ప్రోగ్రామ్ తీసుకొని పూర్తిగా

కాలర్‌లో ఉంచలేము.

మరొక ఫంక్షన్ లోపల ఒక ఫంక్షన్ పూర్తిగా

వ్రాయబడదు.

కాబట్టి, అలా చేయడానికి మిమ్మల్ని అనుమతించే

కొన్ని భాషలు ఉన్నాయి. C మిమ్మల్ని దీన్ని

అనుమతించదు, ఇది మెయిన్ ఫంక్షన్ అని

నేను ఇంతకు ముందు పేర్కొన్నాను.

మీకు బహుళ సబ్ టాస్క్ లు ఉన్నప్పుడు, మీరు

ప్రారంభించాల్సిన మొదటి పని ఏమిటో

ఎవరైనా తెలుసుకోవాలి.

సాధారణంగా ఇది మెయిన్.

కాబట్టి, మీరు మెయిన్‌తో ప్రారంభించండి, మెయిన్‌కి

దశల క్రమం ఉంటుంది, మెయిన్ నుండి మీకు

కావలసిన ఏదైనా డ్యూటీ డెలిగేషన్ కావాలంటే,

మెయిన్ ప్రోగ్రామ్‌లో అది ఉండాలి, మెయిన్

ఫంక్షన్‌లో డ్యూటీ డెలిగేషన్ ఉండాలి.

మేము మెయిన్ ఫంక్షన్ నుండి పవర్ కి డ్యూటీ

డెలిగేషన్ ని కలిగి ఉన్నాము.

కాబట్టి, ఎగ్జిక్యూషన్ మెయిన్ ఫంక్షన్ నుండి

ప్రారంభమవుతుంది, కంట్రోల్ ఫ్లో అక్కడ

మొదలవుతాయి, అక్కడ నుండి కంట్రోల్ ఫ్లో

ఒక ఫంక్షన్ లేదా మరొకదానికి తరలించవచ్చు

మరియు వెనుకకు తిరిగి వస్తుంది.

మీరు కాలర్ నుండి కొత్త ఫంక్షన్‌కి

కాల్ చేసిన ప్రతిసారీ, మీరు తప్పనిసరిగా

కంట్రోల్ ను కాళ్ళీ కి బదిలీ చేస్తున్నారు.

కాబట్టి, ఫంక్షన్ కాల్‌తో మీరు సాధారణంగా

కొన్ని పారామీటర్స్ లను పాస్ చేస్తారు.

మన విషయంలో మనం బేస్ మరియు nని పాస్ చేసాము

మరియు ఈ పారామీటర్స్ ఫంక్షన్‌లో ఉపయోగించబడతాయి.

మీరు కొంత విలువను గణిస్తారు, విలువలు

కాలర్‌కు తిరిగి వస్తాయి మరియు కాలర్

దానిని వేరే గణనలో ఉపయోగించవచ్చు.

కాలర్, ఉత్పత్తి చేయబడిన విలువను

విస్మరించడాన్ని కూడా ఎంచుకోవచ్చు.

నిజానికి, printf సాంకేతికంగా సరైనది, వాస్తవానికి

తిరిగి విలువను ఉత్పత్తి చేస్తుంది.

కేవలం, సాధారణంగా మేము printf నుండి రిటర్న్

విలువను విస్మరించడాన్ని ఎంచుకుంటాము.

ఇది కొంత పని చేస్తుంది, ఇది స్క్రీన్‌పై

విషయాలను ప్రింట్ చేస్తుంది, ఇది వాస్తవానికి

విలువను కూడా అందిస్తుంది, మేము సాధారణంగా రిటర్న్

విలువ గురించి పట్టించుకోము.

ఇది చాలా మంది ప్రోగ్రామర్లకు ఉపయోగపడదు.

ఫంక్షన్ యొక్క టెంప్లేట్ ని చూద్దాం.

మాకు ఫంక్షన్ పేరు ఉంది మరియు మా వద్ద

అన్ని ఆర్గ్యుమెంట్ డిక్లరేషన్‌లు ఉన్నాయి

మరియు మాకు రిటర్న్ టైపు ఉంది మరియు

మీరు మీ ప్రోగ్రామ్‌లోనే మరిన్ని డిక్లరేషన్‌లను

కోరుకోవచ్చు.

మీకు స్టేట్‌మెంట్‌లలో మరిన్ని డిక్లరేషన్‌లు

ఉన్నాయి మరియు చివరగా, మీకు రిటర్న్ ఎక్స్‌ప్రెషన్

ఉంటుంది.

ఫంక్షన్ పేరు, మీరు ఈ సబ్ టాస్క్ కాల్

చేయబోయే పేరును గుర్తిస్తుంది.

ఇది కొన్ని ఆర్గుమెంట్స్ ని కలిగి ఉండవచ్చు,

ఆర్గుమెంట్స్ వాటి పేర్లు మరియు ఆర్గుమెంట్

లు ఇవ్వవలసిన క్రమాన్ని కలిగి ఉంటాయి.

ఉదాహరణకు, పవర్ ఆఫ్ బేస్ కామా n కి మీరు

3 కామా 5ని పాస్ చేస్తే, మేము 3 పవర్ 5 చేస్తాము.

బదులుగా, మీరు పవర్ ఆఫ్ 5 కామా 3 అని చెబితే,

అది వాస్తవానికి 5 పవర్ 3 అని అర్ధం,

మీకు ఫలితం 125 వస్తుంది.

కాబట్టి, మీరు గుర్తించడంలో జాగ్రత్తగా ఉండాలి,

ఆర్గుమెంట్స్ ఏమిటి మరియు ఆర్గుమెంట్స్

ఏ క్రమంలో పాస్ చేయబడ్డాయి మరియు మీరు ఫంక్షన్

లో ఉన్న వివిధ ప్రకటనలను కలిగి ఉంటారు.

ఉదాహరణకు, మనకు int i మరియు int p అవసరమవుతాయి,

ఇవి లూప్‌ను అమలు చేయడంలో ఉపయోగపడతాయి.

చివరగా, మనకు రిటర్న్ ఎక్స్‌ప్రెషన్ ఉంది,

ముందుగా pని రిటర్న్ చేయండి మరియు మా

పవర్ ఫంక్షన్‌లో రిటర్న్ టైప్ ఉంది,

అది ఇంటీజర్.

మీరు గుర్తుంచుకోవాల్సిన ఒక విషయం ఏమిటంటే,

ఒక ఫంక్షన్ యొక్క బాడీ లో, ఇది కోడ్

యొక్క ప్రాథమిక బ్లాక్ మరియు ఫంక్షన్ యొక్క

బాడీలో ఉంటుంది, మీరు ఇతర ఫంక్షన్

డిక్లరేషన్‌లను కలిగి ఉండలేరు.

కాబట్టి, మరొక ఫంక్షన్‌లో పూర్తిగా ప్రకటించబడిన

మరియు వివరించబడిన ఇతర ఫంక్షన్‌లను

కలిగి ఉండటానికి ఇది అనుమతించబడదు.

ఆర్గ్యుమెంట్‌లు తప్పనిసరిగా ఇన్‌పుట్‌లను

కనుగొన్నాయి, మీకు టైప్స్ మరియు ఆర్డర్

రెండూ అవసరం.

కొన్నిసార్లు, రిటర్న్ ఎక్స్‌ప్రెషన్ ఐచ్ఛికం.

కాబట్టి, కీవర్డ్ రిటర్న్ ఎక్స్‌ప్రెషన్‌ను

తీసుకోవచ్చు, అది ఎలాంటి ఎక్స్‌ప్రెషన్‌ను

తీసుకోదు మరియు రిటర్న్ అని చెప్పదు లేదా

మీకు రిటర్న్ కూడా లేకపోతే, మీ ప్రోగ్రామ్

సబ్ టాస్క్ యొక్క చివరి ముగింపు బ్రేస్

కు వస్తుంది మరియు స్వయంచాలకంగా, అది

కాలర్‌కి తిరిగి వెళుతుంది.

కాబట్టి, ఫంక్షన్‌ను ప్రారంభించడం సాధారణంగా

ఈ ఫంక్షన్ పేరును ఉపయోగించి చేయబడుతుంది

మరియు మీరు ఆమోదించిన అన్ని పారామీటర్

ల సమితిని కలిగి ఉంటారు.

ఫంక్షన్ యొక్క ప్రోటోటైప్ అని పిలవబడే దాని

గురించి ఈ భావన ఉంది.

మేము దీన్ని కొద్దిసేపట్లో చూస్తాము.

నేను ఒక ప్రోగ్రామ్‌లో దాన్ని కలిగి ఉన్నాను,

కానీ నేను ఇంతకు ముందు దాని వివరాలలోకి

వెళ్లలేదు, కానీ ప్రోటోటైప్ అంటే

ఏమిటో చూద్దాం.

ప్రోటోటైప్ తప్పనిసరిగా పారామీటర్ ల సంఖ్య

మరియు ప్రతి పారామీటర్ రకాన్ని నిర్వచిస్తుంది.

ఇది ఫంక్షన్ యొక్క రిటర్న్ విలువను

కూడా నిర్వచిస్తుంది.

ప్రోటోటైప్ తప్పనిసరిగా మీకు బ్లాక్ బాక్స్

వివరణను ఇస్తుంది.

ప్రతి ఫంక్షన్‌కు ప్రోటోటైప్ , ఫంక్షన్

యొక్క వాస్తవ నిర్వచనం ఉంటుంది.

బ్లాక్ బాక్స్ వివరణ ఏమిటో ప్రోటోటైప్

మీకు చెబుతుంది, ఇన్‌పుట్‌లు ఏమిటి

మరియు అవుట్‌పుట్‌లు ఏమిటి మరియు కొన్నింటిలో

మీరు ఫంక్షన్‌ను చేయడానికి ప్రోగ్రామ్‌ను

వ్రాయవలసి ఉంటుంది మరియు అది ఫంక్షన్

అమలు.

ప్రోటోటైప్ అవసరమైన విషయం, కంపైలర్‌లు

సాధారణంగా ప్రోటోటైప్ ఉందా లేదా అని తనిఖీ

చేస్తాయి.

మేము ప్రోటోటైప్ ఇస్తే, మీరు ఏదైనా

మర్చిపోయినట్లయితే కంపైలర్ వాస్తవానికి

హెచ్చరికల ద్వారా సూచిస్తుంది.

మీరు ఒక ఫంక్షన్‌ని రిటర్న్ చేసారు మరియు

దానికి మూడు పారామీటర్‌లు అందిస్తారు మరియు

మీరు దానిని పిలిచిన ప్రతిచోటా, మీరు

రెండు పారామీటర్‌లు మాత్రమే పాస్ చేస్తారు.

కంపైలర్ దానిని గుర్తించి, ఈ ఫంక్షన్ మూడు పారామీటర్

లను ఆశిస్తున్నట్లు మరియు మీరు కేవలం

రెండింటిని మాత్రమే పాస్ చేసారని మీకు

తెలియజేస్తుంది.

ఇక్కడ ప్రోటోటైప్ పవర్, ఈ క్రింది విధంగా

ఉంది, int power . కాబట్టి, ఈ స్థానంలో మనము

వాస్తవానికి పారామీటర్స్ పేరు పెట్టబడలేదు,

పవర్ రెండు పారామీటర్ లను తీసుకుంటుంది,

కానీ పేర్లు పేర్కొనబడలేదు.

కంపైలర్ ఈ ప్రోటోటైప్‌ను చూసినప్పుడు, పవర్

రెండు ఇంటిజెర్ లను తీసుకునే ఒక ఫంక్షన్‌గా

భావించబడి, మరొక ఇంటిజెర్ ని తిరిగి

ఇస్తుంది.

ఈ సమయంలో, కంపైలర్‌కు బేస్ మొదటి పారామీటర్

మరియు n రెండవ పారామీటర్ లేదా n మొదటి పారామీటర్

మరియు బేస్ రెండవ పారామీటర్ కాదా అనేది

తెలియదు.

నిజానికి, అది ఈ సమయంలో పట్టించుకోడు.

అయితే, తరువాత మేము నిజానికి వేరియబుల్స్

బేస్ మరియు n ఇక్కడ ఉంచాము మరియు తగిన

విధంగా ప్రోగ్రామ్‌ను వ్రాస్తాము.

సాధారణంగా, ప్రోగ్రామ్ ప్రారంభంలో ఫంక్షన్

ప్రోటోటైప్‌లు ఇవ్వబడతాయి.

ఇది చూద్దాం, నేను ఇంతకు ముందు కలిగి

ఉన్న అదే కోడ్ భాగాన్ని చూపుతున్నాను.

మనకు ఈ పవర్ ఫంక్షన్ ఉంది.

కాబట్టి, మీరు కుడి వైపున చూసేదాన్ని

ఫంక్షన్ డెఫినిషన్ లేదా ఫంక్షన్ వివరణ

అని పిలుస్తారు.

ఇక్కడ ఈ లైన్‌లో మీరు చూసేదాన్ని,

ఎడమ వైపున ఫంక్షన్ ప్రోటోటైప్ అంటారు.

మనకు ఫంక్షన్ ప్రోటోటైప్ మరియు ఫంక్షన్ డెఫినిషన్

ఉన్నాయి.

ఫంక్షన్ ప్రోటోటైప్ చాలా ఆసక్తికరంగా

లేదు, కానీ కంపైలర్‌కు చెప్పడం అవసరం, అలాగే

పవర్ వాస్తవానికి రెండు వేరియబుల్స్‌ను

ఆశిస్తుంది మరియు అది ఇంటిజెర్ ని

మాత్రమే తిరిగి ఇస్తుంది, అది అక్షరాన్ని తిరిగి

ఇవ్వదు, ఇది ఫ్లోటింగ్ పాయింట్ విలువను

తిరిగి ఇవ్వదు మరియు అందువలన.

ఫంక్షన్‌ను ఉపయోగించే ఎవరికైనా వారు ఏమి

చేస్తున్నారో తెలుసు.

దీనిని ఫంక్షన్ ప్రోటోటైప్ అంటారు మరియు దీనిని

ఫంక్షన్ ఇన్వొకేషన్ అంటారు.

మనం ఫంక్షన్‌ని కాల్ చేసినప్పుడు, మేము

ఆ ఫంక్షన్‌ ఇన్వొకేషన్ లేదా కాలింగ్ ది

ఫంక్షన్‌ అని పిలుస్తాము.

ఇంతకు ముందు నేను చెప్పాను, నేను కంట్రోల్

ఫ్లో అని పిలవబడే దాన్ని తాకాలనుకుంటున్నాను.

నేను చెప్పాను, ప్రోగ్రామ్‌ ఫ్లో అనేది మెయిన్

ప్రోగ్రామ్‌తో మొదలవుతుంది మరియు అది ఫంక్షన్‌ని

కాల్ చేసినప్పుడు అది అక్కడికి వెళ్తుంది

మరియు కొనసాగుతుంది.

నేను ఇప్పుడు కొంచెం స్పష్టంగా చెప్పాలనుకుంటున్నాను.

కాబట్టి, ఈ ప్రోగ్రామ్ భాగాన్ని చూద్దాం

మరియు ఈ ఫంక్షన్ ఎలా లేదా ఈ ప్రోగ్రామ్

ఎలా అమలు చేయబడుతుందో చూద్దాం.

నేను ఇంతకు ముందు చెప్పినట్లుగా, అన్ని

అమలులు మెయిన్‌తో ప్రారంభమవుతాయి,

మీరు మెయిన్‌తో ప్రారంభించండి.

ఈ సమయంలో మీకు రెండు డిక్లరేషన్‌లు ఉన్నాయి,

num1 మరియు num2.

కాబట్టి, ఏదైనా వేరియబుల్స్ మాదిరిగానే, కంపైలర్

num1 మరియు num2 కోసం మెమరీని కేటాయించింది.

కాబట్టి, నేను ఈ పంక్తిని అమలు చేయడానికి సిద్ధంగా

ఉన్నాను, num1 = power . ఆ సమయంలో ఏమి జరుగుతుంది,

ఇక్కడ సాధారణంగా జరిగే తదుపరి లైన్‌కి

వెళ్లే బదులు.

మేము ప్రోగ్రామ్ లను చూసినప్పుడు.

ఫర్ లూప్‌లు మరియు ఇతర విషయాల కోసం,

స్క్రీన్‌పై మీరు చూసే ఈ కోడ్ సీక్వెన్స్

ఎలా అంతర్గతంగా ఎలా అమలు చేయబడుతుందో

మేము ఇంతకు ముందు చూశాము.

కాబట్టి, మీకు లూప్‌లు లేదా బ్రాంచ్ లు

లేకుంటే మీరు లైన్ 1 నుండి ప్రారంభించండి,

మీరు లైన్ 2, లైన్ 3, లైన్ 4, లైన్ n వరకు

వెళ్లి మీరు రిటర్న్ అవుతారు.

ఒకవేళ మీకు ఇఫ్ -థెన్- ఎల్స్ బ్రాంచ్ లు

ఉంటే, ఇఫ్ కండీషన్ నిజమైతే లేదా ఎల్స్

కండీషన్ నిజం మరియు వాటిలో ఒకటి మాత్రమే

పని చేస్తుంది, మా వద్ద ఫర్ లూప్ ఉంటే,

మీకు రిపీటెడ్ బాడీ ఉంటుంది మరియు అవన్నీ

కంట్రోల్ ఫ్లో కి ఉదాహరణలు.

కంట్రోల్ ఫ్లో కి ఇది మరొక ఉదాహరణ.

కాబట్టి, ఈ సమయంలో మీరు మెయిన్‌లో లైన్

నంబర్ 2లో ఉన్నట్లయితే, కంట్రోల్ పవర్ లో

లైన్ నంబర్ 1కి బదిలీ చేయబడుతుంది, ఆపై

మీరు వెళ్లి వాస్తవానికి ఈ ఆపరేషన్ల క్రమాన్ని

చేయండి.

ఈ ఆపరేషన్ల క్రమం పూర్తయిన తర్వాత,

మీరు ఈ లైన్‌కి తిరిగి వెళ్లండి.

మీరు తిరిగి వచ్చినప్పుడు, ఏమి జరుగుతుంది.

మీరు power విలువని గణించారు, దాని ఫలితంగా గణించబడిన

సంఖ్య 243 ఉండాలి మరియు అది సంఖ్య 1కి కేటాయించబడుతుంది.

ఇప్పుడు, మీరు మళ్లీ కాలర్‌లోకి తిరిగి

వచ్చారు, కాలర్‌లో, మీరు డిఫాల్ట్‌గా

తదుపరి లైన్‌కి వెళతారు.

తదుపరి లైన్ కూడా ఫంక్షన్ ఇన్వొకేషన్

లేదా ఫంక్షన్ కాల్, మళ్లీ కంట్రోల్ కాలీ

కి బదిలీ చేయబడుతుంది.

కాలీలో, ఇది ఇక్కడ కోడ్ యొక్క క్రమం

ద్వారా వెళుతుంది, దాని చివరిలో మీరు

కాలర్‌కి తిరిగి వస్తారు.

ఈ సందర్భంలో, -4,3 అనేది -64 అని లెక్కించింది,

ఆ విలువ num2కి కేటాయించబడుతుంది.

కాబట్టి, ఇది ఈ స్థానానికి తిరిగి వస్తుంది

మరియు మీరు ఈ రెండు సంఖ్యల ప్రింటింగ్

చేయడానికి సిద్ధంగా ఉన్నారు.

ఈ ప్రోగ్రామ్ కోసం కంట్రోల్ ఫ్లో, మీరు

మెయిన్ తో ప్రారంభించండి, ఈ లైన్‌లో మీరు ఈ

వైపు పిలుస్తారు.

కాబట్టి, ప్రతి అసైన్‌మెంట్ ఆపరేషన్ కోసం గుర్తుంచుకోండి,

మీరు కుడి వైపున మూల్యాంకనం చేసి,

మీరు దానిని ఎడమ వైపుకు కేటాయించారు.

కాబట్టి, కుడి వైపున మూల్యాంకనం ఉంది.

power అనేది నియంత్రణను పవర్ ఫంక్షన్‌కు

బదిలీ చేస్తుంది మరియు మీరు దశల క్రమాన్ని

చేయండి, కంట్రోల్ ఇక్కడకు తిరిగి వస్తుంది,

మీరు ఈ అసైన్‌మెంట్ చేయండి, నియంత్రణ

డిఫాల్ట్‌గా తదుపరి లైన్ కి వస్తుంది.

మళ్ళీ కుడి వైపున తదుపరి లైన్, అది

ఒక ఫంక్షన్ కాల్ చేస్తుంది, మీరు

దీన్ని చేయండి మీరు ఇక్కడకు తిరిగి వచ్చి,

అసైన్‌మెంట్ చేయండి మరియు మీరు ఒక printf

తర్వాత మరొక printfని కలిగి ఉన్నారు మరియు

అందువలన.

నిజానికి, సాంకేతికంగా printf అనేది మరొక ఫంక్షన్.

కాబట్టి, మీరు ఇక్కడకు వచ్చినప్పుడు, printf

అనేది రెండు పారామీటర్ లు, ఒక ఫార్మాట్ మరియు

విలువను తీసుకునే ఒక ఫంక్షన్.

ఈ రెండూ printfకి పంపబడే పారామీటర్ లు.

నిజానికి, printf లోపల ఏమి జరుగుతుందో అది

దాచబడినది .

కంట్రోల్ వాస్తవానికి printfకి బదిలీ చేయబడుతుంది,

స్క్రీన్‌పై విషయాలను ప్రింట్ చేయడానికి

printf ఏమైనా చేస్తుంది, అది ఈ లైన్‌కి మరియు

తదుపరి లైన్‌కు తిరిగి వస్తుంది, అది కాలర్‌కి

వెళ్తుంది, తదుపరి లైన్‌కి, మళ్లీ ఇది

printf ద్వారా కాల్ చేయబడినది, మీరు printf యొక్క అంతర్గత

విషయాలకి వెళ్ళి, అది స్క్రీన్‌పై

ఏది ప్రింట్ చేయాలో అది చేస్తుంది, తిరిగి

ఇక్కడకు వస్తుంది మరియు అది ఇక్కడకు

వస్తుంది మరియు రిటర్న్‌తో ఈ లైన్‌కు వస్తుంది

మరియు మెయిన్ ఫంక్షన్‌లోని చివరి లైన్ రిటర్న్

0, ఇది 0ని అందిస్తుంది.

మెయిన్ అనేది ఫంక్షన్ అని మీరు గమనించినట్లయితే,

ఇది రిటర్న్ విలువ, ఇది ఫంక్షన్ పేరు

మరియు ఇది రిటర్న్ స్టేట్‌మెంట్ మరియు

మెయిన్ అనేది ఏ పారామీటర్ లను తీసుకోని ఫంక్షన్.

కాబట్టి, మీరు మెయిన్‌కి కూడా ఇన్‌పుట్‌లను

తీసుకునే మార్గాలు ఉన్నాయి.

మేము దానిని తర్వాత తరగతిలో కవర్ చేస్తాము.

కాబట్టి, మెయిన్ ఒక ఫంక్షన్ మరియు

పవర్ కూడా ఒక ఫంక్షన్.

printf మరియు scanf లు కూడా ఫంక్షన్ మరియు మొదలైనవి.

కాబట్టి, నేను కొద్దిగా భిన్నమైన ఉదాహరణను

చూపించాలనుకుంటున్నాను.

ఇక్కడ మనం లూప్ లోపల అదే పవర్ ఫంక్షన్‌ని

ఉపయోగిస్తాము.

ఇక్కడ Int పవర్ ఉంటుంది.

ఈ పవర్ ఫంక్షన్ ఫలితాన్ని గణిస్తుంది, అది

తిరిగి వస్తుంది.

కాబట్టి, మీరు లూప్ నుండి వచ్చిన i ని

కలిగి ఉన్నారు, 3 పవర్ i, పవర్ ఫంక్షన్ నుండి

వచ్చేది, - 4 పవర్ i, పవర్ ఫంక్షన్ నుండి

వచ్చేది, printf దానికి అవసరమైన అన్ని విలువలను

కలిగి ఉంటుంది, ఇది స్క్రీన్‌పై విషయాలను

ప్రింట్ చేస్తుంది.

ఆపై కంట్రోల్ ఈ స్థానానికి వస్తుంది.

ఈ సమయంలో, ఇది తనిఖీ చేయమని చెబుతుంది,

ఫర్ లూప్ చివరకి వెళ్లండి, ఇది i + +

. కాబట్టి, మీరు i + + అయిన పోస్ట్ లూప్

ఫంక్షన్‌ని చేయాలి.

i < 20 ఉన్నాదో లేదో మళ్లీ తనిఖీ చేయండి,

కాబట్టి, i = 1 అయ్యి ఉండేది.

. ఇది ఇప్పటికీ 20 కంటే

తక్కువగా ఉంది, మళ్లీ printf ఉన్న ఈ లైన్‌కు

వస్తుంది.

ఈ సమయంలో, ఇది రెండు ఫంక్షన్ కాల్‌లను

చేస్తుంది, ఇది ఆర్గ్యుమెంట్‌లను పొంది, స్క్రీన్‌పై

విషయాలను ప్రింట్ చేస్తుంది, ఫర్ స్టేట్‌మెంట్

ముగింపుకు తిరిగి వస్తుంది, ఆ సమయంలో

మీరు మళ్లీ i ని ఇంక్రిమెంట్ చేయండి.

కాబట్టి, ఇది కొంచెం సంక్లిష్టమైన కంట్రోల్

ఫ్లో.

మీకు లూప్‌లు ఉన్నాయి మరియు మీకు ఇక్కడ

వివిధ ఫంక్షన్ కాల్‌లు ఉన్నాయి.

కాబట్టి, i = 3 తో చేసిన ఈ ఉదాహరణను తీసుకుందాం.

కాబట్టి, మనం ఏదో ఒక సమయంలో, లూప్‌లో

i = 3 గా ఉండేది, అది ఎలా జరిగిందో, ఎలా

జరిగేదో చూద్దాం.

i = 3కి సమానం అయినప్పుడు, printf పవర్ ని కాల్ చేస్తుంది.

పవర్ , ఆ సమయంలో, ఆ బదిలీ ఈ విభాగానికి

వెళుతుంది మరియు మీరు 3 పవర్ iని కలిగి

ఉన్నందున, ఈ సందర్భంలో 3 పవర్ 3, అంటే 27, ఫలితం

తిరిగి వస్తుంది మరియు అది తాత్కాలిక

ప్లేస్ హోల్డర్. 27 తిరిగి వస్తుంది,

మీకు ఇప్పటికే ఉన్న i ఉంది మరియు మీకు

27 ఉన్నాయి.

కాబట్టి, మీకు రెండు పారామీటర్‌లు సిద్ధంగా

ఉన్నాయి.

printfకి, ప్రింట్ చేయడానికి ఇంకా ఒక పారామీటర్

అవసరం.

కాబట్టి, ఆ సమయంలో, ఇది పవర్ అని మీరు

చూస్తారు, అది మూల్యాంకనం చేయబడుతుంది.

ఫలితం= - 64, అది printf కి విలువగా తిరిగి వస్తుంది.

ఈ సమయంలో మీకు 3, 27 మరియు - 64 ఉన్నాయి,

printf లో ప్రింట్ చేయాల్సిన ప్రతిదీ ఉంది.

కాబట్టి, printf ఫంక్షన్ కాల్ చేయబడుతుంది,

ఆ సమయంలో మీరు 3, 27ని ప్రింట్ చేస్తారు.

కాబట్టి, స్క్రీన్‌పై 3 స్పేస్ 27 స్పేస్

- 64 అని ప్రింట్ చేసి, ఆపై మీరు iలో తదుపరి

పునరావృతానికి వెళ్లడానికి సిద్ధంగా ఉన్నారు.