In this chapter:
The Chat Application
Now that you understand Message-Oriented Middleware and some JMS concepts, you are ready to write your first JMS application. This chapter provides a gentle introduction to JMS using the publish-and-subscribe messaging model. You will get your feet wet with JMS and learn some of the basic classes and interfaces. Chapter 4, Publish-and-Subscribe Messaging, covers publish-and-subscribe in detail, and Chapter 5, Point-to-Point Messaging, covers the point-to-point message model.
As with all examples in this book, example code and instructions specific to several vendors is provided in the book download at O’Reilly’s web site (see the Preface for details). You will need to install and configure your JMS provider according to the instructions provided by your vendor.
The Chat Application
Internet chat provides an interesting application for learning about the JMS pub/sub messaging model. Used mostly for entertainment, web-based chat applications can be found on thousands of web sites. In a chat application, people join virtual chat rooms where they can “chat” with a group of other people.
To illustrate how JMS works, we will use the JMS pub/sub API to build a simple chat application. The requirements of Internet chat map neatly onto the publish-and-subscribe messaging model. In this model, a producer can send a message to many consumers by delivering the message to a single topic. A message producer is also called a publisher and a message consumer is also called a subscriber. In reality, using JMS for a chat application would be overkill, since chat systems don’t require enterprise quality service.
The following source code is a JMS-based chat client. Every participant in a chat session uses this Chat program to join a specific chat room (topic), and deliver and receive messages to and from that room:
package chap2.chat;

import javax.jms.*;
import javax.naming.*;
import java.io.*;
import java.io.InputStreamReader;
import java.util.Properties;

public class Chat implements javax.jms.MessageListener{
private TopicSession pubSession;
private TopicSession subSession;
private TopicPublisher publisher;
private TopicConnection connection;
private String username;

/* Constructor. Establish JMS publisher and subscriber */
public Chat(String topicName, String username, String password)
throws Exception {
// Obtain a JNDI connection
Properties env = new Properties( );
// … specify the JNDI properties specific to the vendor

InitialContext jndi = new InitialContext(env);

// Look up a JMS connection factory
TopicConnectionFactory conFactory =
(TopicConnectionFactory)jndi.lookup(“TopicConnectionFactory”);

// Create a JMS connection
TopicConnection connection =
conFactory.createTopicConnection(username,password);

// Create two JMS session objects
TopicSession pubSession =
connection.createTopicSession(false,
Session.AUTO_ACKNOWLEDGE);
TopicSession subSession =
connection.createTopicSession(false,
Session.AUTO_ACKNOWLEDGE);

// Look up a JMS topic
Topic chatTopic = (Topic)jndi.lookup(topicName);

// Create a JMS publisher and subscriber
TopicPublisher publisher =
pubSession.createPublisher(chatTopic);
TopicSubscriber subscriber =
subSession.createSubscriber(chatTopic);

// Set a JMS message listener
subscriber.setMessageListener(this);

// Intialize the Chat application
set(connection, pubSession, subSession, publisher, username);

// Start the JMS connection; allows messages to be delivered
connection.start( );

}
/* Initialize the instance variables */
public void set(TopicConnection con, TopicSession pubSess,
TopicSession subSess, TopicPublisher pub,
String username) {
this.connection = con;
this.pubSession = pubSess;
this.subSession = subSess;
this.publisher = pub;
this.username = username;
}
/* Receive message from topic subscriber */
public void onMessage(Message message) {
try {
TextMessage textMessage = (TextMessage) message;
String text = textMessage.getText( );
System.out.println(text);
} catch (JMSException jmse){ jmse.printStackTrace( ); }
}
/* Create and send message using topic publisher */
protected void writeMessage(String text) throws JMSException {
TextMessage message = pubSession.createTextMessage( );
message.setText(username+” : “+text);
publisher.publish(message);
}
/* Close the JMS connection */
public void close( ) throws JMSException {
connection.close( );
}
/* Run the Chat client */
public static void main(String [] args){
try{
if (args.length!=3)
System.out.println(“Topic or username missing”);

// args[0]=topicName; args[1]=username; args[2]=password
Chat chat = new Chat(args[0],args[1],args[2]);

// Read from command line
BufferedReader commandLine = new
java.io.BufferedReader(new InputStreamReader(System.in));

// Loop until the word “exit” is typed
while(true){
String s = commandLine.readLine( );
if (s.equalsIgnoreCase(“exit”)){
chat.close( ); // close down connection
System.exit(0);// exit program
} else
chat.writeMessage(s);
}
} catch (Exception e){ e.printStackTrace( ); }
}
}
Getting Started with the Chat Example
To put this client to use, compile it like any other Java program. Then start your JMS server, setting up whatever topics, usernames, and passwords you want. Configuration of a JMS server is vendor-dependent, and won’t be discussed here.
The Chat class includes a main( ) method so that it can be run as a standalone Java application. It’s executed from the command line as follows:
java chap2.chat.Chat topic username password
The topic is the destination that we want to publish-and-subscribe to; username and password make up the authentication information for the client. Run at least two chat clients in separate command windows and try typing into one; you should see the text you type displayed by the other client.
Before examining the source code in detail, a quick explanation will be helpful. The chat client creates a JMS publisher and subscriber for a specific topic. The topic represents the chat room. The JMS server registers all the JMS clients that want to publish or subscribe to a specific topic. When text is entered at the command line of one of the chat clients, it is published to the messaging server. The messaging server identifies the topic associated with the publisher and delivers the message to all the JMS clients that have subscribed to that topic. As Figure 2-1 illustrates, messages published by any one of the JMS clients are delivered to all the JMS subscribers for that topic.
Figure 2-1. The Chat application

Examining the Source Code
Running the Chat example in a couple of command windows demonstrates what the Chat application does. The rest of this chapter examines the source code for the Chat application so that you can see how the Chat application works.
Bootstrapping the JMS client
The main( ) method bootstraps the chat client and provides a command-line interface. Once an instance of the Chat class is created, the main( ) method spends the rest of its time reading text typed at the command line and passing it to the Chat instance using the instance’s writeMessage( ) method.
The Chat instance connects to the topic and receives and delivers messages. The Chat instance starts its life in the constructor, which does all the work to connect to the topic and set up the TopicPublisher and TopicSubscribers for delivering and receiving messages.
Obtaining a JNDI connection
The chat client starts by obtaining a JNDI connection to the JMS messaging server. JNDI is an implementation-independent API for directory and naming systems. A directory service provides JMS clients with access to ConnectionFactory and Destinations (topics and queues) objects. ConnectionFactory and Destination objects are the only things in JMS that cannot be obtained using the JMS API–unlike connections, sessions, producers, consumers, and messages, which are manufactured using the JMS API. JNDI provides a convenient, location-transparent, configurable, and portable mechanism for obtaining ConnectionFactory and Destination objects, also called JMS administered objects because they are established and configured by a system administrator.
Using JNDI, a JMS client can obtain access to a JMS provider by first looking up a ConnectionFactory. The ConnectionFactory is used to create JMS connections, which can then be used for sending and receiving messages. Destination objects, which represent virtual channels (topics and queues) in JMS, are also obtained via JNDI and are used by the JMS client. The directory service can be configured by the system administrator to provide JMS administered objects so that the JMS clients don’t need to use proprietary code to access a JMS provider.
JMS servers will either work with a separate directory service (e.g., LDAP) or provide their own directory service that supports the JNDI API. For more details on JNDI, see the sidebar “Understanding JNDI.”
The constructor of the Chat class starts by obtaining a connection to the JNDI naming service used by the JMS server:
Understanding JNDI
JNDI is a standard Java extension that provides a uniform API for accessing a variety of directory and naming services. In this respect, it is somewhat similar to JDBC. JDBC lets you write code that can access different relational databases such as Oracle, SQLServer, or Sybase; JNDI lets you write code that can access different directory and naming services, such as LDAP, Novell Netware NDS, CORBA Naming Service, and proprietary naming services provided by JMS servers.
In JMS, JNDI is used mostly as a naming service to locate administered objects. Administered objects are JMS objects that are created and configured by the system administrator. Administered objects include JMS ConnectionFactory and Destination objects like topics and queues.
Administered objects are bound to a name in a naming service. A naming service associates names with distributed objects, files, and devices so that they can be located on the network using simple names instead of cryptic network addresses. An example of a naming service is the DNS, which converts an Internet hostname like www.oreilly.com into a network address that browsers use to connect to web servers. There are many other naming services, such as COSNaming in CORBA and the Java RMI registry. Naming services allow printers, distributed objects, and JMS administered objects to be bound to names and organized in a hierarchy similar to a filesystem. A directory service is a more sophisticated kind of naming service.
JNDI provides an abstraction that hides the specifics of the naming service, making client applications more portable. Using JNDI, JMS clients can browse a naming service and obtain references to administered objects without knowing the details of the naming service or how it is implemented. JMS servers are usually be used in combination with a standard JNDI driver (a.k.a. service provider) and directory service like LDAP, or provide a proprietary JNDI service provider and directory service.
JNDI is both virtual and dynamic. It is virtual because it allows one naming service to be linked to another. Using JNDI, you can drill down through directories to files, printers, JMS administered objects, and other resources following virtual links between naming services. The user doesn’t know or care where the directories are actually located. As an administrator, you can create virtual directories that span a variety of different services over many different physical locations.
JNDI is dynamic because it allows the JNDI drivers for specific types of naming and directory services to be loaded dynamically at runtime. A driver maps a specific kind of naming or directory service into the standard JNDI class interfaces. Drivers have been created for LDAP, Novell NetWare NDS, Sun Solaris NIS+, CORBA COSNaming, and many other types of naming and directory services, including proprietary ones. Dynamically loading JNDI drivers (service providers) makes it possible for a client to navigate across arbitrary directory services without knowing in advance what kinds of services it is likely to find.
// Obtain a JNDI connection
Properties env = new Properties( );
// … specify the JNDI properties specific to the vendor

InitialContext jndi = new InitialContext(env);
Creating a connection to a JNDI naming service requires that a javax.naming.InitialContext object be created. An InitialContext is the starting point for any JNDI lookup–it’s similar in concept to the root of a filesystem. The InitialContext provides a network connection to the directory service that acts as a root for accessing JMS administered objects. The properties used to create an InitialContext depend on which JMS directory service you are using. The code used to create a JNDI InitialContext in BEA’s Weblogic naming service, for example, would look something like this:
Properties env = new Properties( );
env.put(Context.SECURITY_PRINCIPAL, “guest”);
env.put(Context.SECURITY_CREDENTIALS, “guest”);
env.put(Context.INITIAL_CONTEXT_FACTORY,
“weblogic.jndi.WLInitialContextFactory”);
env.put(Context.PROVIDER_URL, “t3://localhost:7001″);

InitialContext jndi = new InitialContext(env);
When SonicMQ is used in combination with a third party LDAP directory service, the connection properties would be very different. For example, the following shows how a SonicMQ JMS client would use JNDI to access JMS administered objects stored in a LDAP directory server:
Properties env = new Properties( );
env.put(Context.SECURITY_PRINCIPAL, “guest”);
env.put(Context.SECURITY_CREDENTIALS, “guest”);
env.put(Context.INITIAL_CONTEXT_FACTORY,
“com.sun.jndi.ldap.LdapCtxFactory”);
env.put(Context.PROVIDER_URL,
“ldap://localhost:389/o=acme.com”);

InitialContext jndi = new InitialContext(env);
NOTE: Alternatively, the InitialContext( ) can be created without properties (no-arg constructor). In this case JNDI will read the vendor-specific JNDI properties from a special file in the classpath named jndi.properties. This eliminates provider-specific code in JMS clients, making them more portable.
The TopicConnectionFactory
Once a JNDI InitialContext object is instantiated, it can be used to look up the TopicConnectionFactory in the messaging server’s naming service:
TopicConnectionFactory conFactory =
(TopicConnectionFactory)jndi.lookup(“TopicConnectionFactory”);
The javax.jms.TopicConnectionFactory is used to manufacture connections to a message server. A TopicConnectionFactory is a type of administered object, which means that its attributes and behavior are configured by the system administrator responsible for the messaging server. The TopicConnectionFactory is implemented differently by each vendor, so configuration options available to system administrators vary from product to product. A connection factory might, for example, be configured to manufacture connections that use a particular protocol, security scheme, clustering strategy, etc. A system administrator might choose to deploy several different TopicConnectionFactory objects, each configured with its own JNDI lookup name.
The TopicConnectionFactory provides two overloaded versions of the createTopicConnection( ) method:
package javax.jms;

public interface TopicConnectionFactory extends ConnectionFactory {
public TopicConnection createTopicConnection( )
throws JMSException, JMSSecurityException;
public TopicConnection createTopicConnection(String username,
String password) throws JMSException, JMSSecurityException;
}
These methods are used to create TopicConnection objects. The behavior of the no-arg method depends on the JMS provider. Some JMS providers will assume that the JMS client is connecting under anonymous security context, while other providers may assume that the credentials can be obtained from JNDI or the current thread.[1] The second method provides the client with a username-password authentication credential, which can be used to authenticate the connection. In our code, we choose to authenticate the connection explicitly with a username and password.
The TopicConnection
The TopicConnection is created by the TopicConnectionFactory :
// Look up a JMS connection factory
TopicConnectionFactory conFactory =
(TopicConnectionFactory)jndi.lookup(“TopicConnectionFactory”);

// Create a JMS connection
TopicConnection connection =
conFactory.createTopicConnection(username, password);
The TopicConnection represents a connection to the message server. Each TopicConnection that is created from a TopicConnectionFactory is a unique connection to the server.[2] A JMS client might choose to create multiple connections from the same connection factory, but this is rare as connections are relatively expensive (each connection requires a network socket, I/O streams, memory, etc.). Creating multiple Session objects (discussed later in this chapter) from the same connection is considered more efficient, because sessions share access to the same connection. The TopicConnection is an interface that extends javax.jms.Connection interface. It defines several general-purpose methods used by clients of the TopicConnection. Among these methods are the start( ), stop( ), and close( ) methods:
// javax.jms.Connection the super interface
public interface Connection {
public void start( ) throws JMSException;
public void stop( ) throws JMSException;
public void close( ) throws JMSException;
…
}

// javax.jms.TopicConnection extends javax.jms.Connection
public interface TopicConnection extends Connection {
public TopicSession createTopicSession(boolean transacted,
int acknowledgeMode)
throws JMSException;
…
}
The start( ), stop( ), and close( ) methods allow a client to manage the connection directly. The start( ) method turns the inbound flow of messages “on,” allowing messages to be received by the client. This method is used at the end of the constructor in Chat class:
…
// Intialize the Chat application
set(connection, pubSession, subSession, publisher, username);

connection.start( );

}
It is a good idea to start the connection after the subscribers have been set up, because the messages start to flow in from the topic as soon as start( ) is invoked.
The stop( ) method blocks the flow of inbound messages until the start( ) method is invoked again. The close( ) method is used to close the TopicConnection to the message server. This should be done when a client is finished using the TopicConnection; closing the connection conserves resources on the client and server. In the Chat class, the main( ) method calls Chat.close( ) when “exit” is typed at the command line. The Chat.close( ) method in turn calls the TopicConnection.close( ) method:
public void close( ) throws JMSException {
connection.close( );
}
Closing a TopicConnection closes all the objects associated with the connection including the TopicSession, TopicPublisher, and TopicSubscriber.
The TopicSession
After the TopicConnection is obtained, it’s used to create TopicSession objects:
// Create a JMS connection
TopicConnection connection =
conFactory.createTopicConnection(username,password);

// Create two JMS session objects
TopicSession pubSession =
connection.createTopicSession(false,
Session.AUTO_ACKNOWLEDGE);
TopicSession subSession =
connection.createTopicSession(false,
Session.AUTO_ACKNOWLEDGE);
A TopicSession object is a factory for creating Message, TopicPublisher, and TopicSubscriber objects. A client can create multiple TopicSession objects to provide more granular control over publishers, subscribers, and their associated transactions. In this case we create two TopicSession objects, pubSession and subSession. We need two objects because of threading restrictions in JMS, which are discussed in the “Sessions and Threading” section later in the chapter.
The boolean parameter in the createTopicSession( ) method indicates whether the Session object will be transacted. A transacted Session automatically manages outgoing and incoming messages within a transaction. Transactions are important but not critical to our discussion at this time, so the parameter is set to false, which means the TopicSession will not be transacted. Transactions are discussed in more detail in Chapter 6, Guaranteed Messaging, Transactions, Acknowledgments, and Failures.
The second parameter indicates the acknowledgment mode used by the JMS client. An acknowledgment is a notification to the message server that the client has received the message. In this case we chose AUTO_ACKNOWLEDGE, which means that the message is automatically acknowledged after it is received by the client.
The TopicSession objects are used to create the TopicPublisher and TopicSubscriber. The TopicPublisher and TopicSubscriber objects are created with a Topic identifier and are dedicated to the TopicSession that created them; they operate under the control of a specific TopicSession:
TopicPublisher publisher =
pubSession.createPublisher(chatTopic);
TopicSubscriber subscriber =
subSession.createSubscriber(chatTopic);
The TopicSession is also used to create the Message objects that are delivered to the topic. The pubSession is used to create Message objects in the writeMessage( ) method. When you type text at the command line, the main( ) method reads the text and passes it to the Chat instance by invoking writeMessage( ). The writeMessage( ) method (shown in the following example) uses the pubSession object to generate a TextMessage object that can be used to deliver the text to the topic:
protected void writeMessage(String text) throws JMSException{
TextMessage message = pubSession.createTextMessage( );
message.setText(username+” : “+text);
publisher.publish(message);
}
Several Message types can be created by a TopicSession. The most commonly used type is the TextMessage.
The Topic
JNDI is used to locate a Topic object, which is an administered object like the TopicConnectionFactory :
InitialContext jndi = new InitialContext(env);
.
.
// Look up a JMS topic
Topic chatTopic = (Topic)jndi.lookup(topicName);
A Topic object is a handle or identifier for an actual topic, called a physical topic, on the messaging server. A physical topic is an electronic channel to which many clients can subscribe and publish. A topic is analogous to a news group or list server: when a message is sent to a news group or list server, it is delivered to all the subscribers. Similarly, when a JMS client delivers a Message object to a topic, all the clients subscribed to that topic receive the Message.
The Topic object encapsulates a vendor-specific name for identifying a physical topic in the messaging server. The Topic object has one method, getName( ), which returns the name identifier for the physical topic it represents. The name encapsulated by a Topic object is vendor-specific and varies from product to product. For example, one vendor might use dot (“.”) separated topic names, like “oreilly.jms.chat”, while another vendor might use a completely different naming system, similar to LDAP naming, “o=oreilly,cn=chat”. Using topic names directly will result in client applications that are not portable across brands of JMS servers. The Topic object hides the topic name from the client, making the client more portable.
As a convention, we’ll refer to a physical topic as a topic and only use the term “physical topic” when it’s important to stress its difference from a Topic object.
The TopicPublisher
A TopicPublisher was created using the pubSession and the chatTopic:
// Look up a JMS topic
Topic chatTopic = (Topic)jndi.lookup(topicName);

// Create a JMS publisher and subscriber
TopicPublisher publisher =
pubSession.createPublisher(chatTopic);
A TopicPublisher is used to deliver messages to a specific topic on a message server. The Topic object used in the createPublisher( ) method identifies the topic that will receive messages from the TopicPublisher. In the Chat example, any text typed on the command line is passed to the Chat class’s writeMessage( ) method. This method uses the TopicPublisher to deliver a message to the topic:
protected void writeMessage(String text) throws JMSException{
TextMessage message = pubSession.createTextMessage( );
message.setText(username+” : “+text);
publisher.publish(message);
}
The TopicPublisher objects deliver messages to the topic asynchronously. Asynchronous delivery and consumption of messages is a key characteristic of Message-Oriented Middleware; the TopicPublisher doesn’t block or wait until all the subscribers receive the message. Instead, it returns from the publish( ) method as soon as the message server receives the message. It’s up to the message server to deliver the message to all the subscribers for that topic.
The TopicSubscriber
The TopicSubscriber is created using the subSession and the chatTopic:
// Look up a JMS topic
Topic chatTopic = (Topic)jndi.lookup(topicName);

// Create a JMS publisher and subscriber
TopicPublisher publisher =
pubSession.createPublisher(chatTopic);
TopicSubscriber subscriber =
subSession.createSubscriber(chatTopic);
A TopicSubscriber receives messages from a specific topic. The Topic object argument used in the createSubscriber( ) method identifies the topic from which the TopicSubscriber will receive messages.
The TopicSubscriber receives messages from the message server one at a time (serially). These messages are pushed from the message server to the TopicSubscriber asynchronously, which means that the TopicSubscriber does not have to poll the message server for messages. In our example, each chat client will receive any message published by any of the other chat clients. When a user enters text at the command line, the text message is delivered to all other chat clients that subscribe to the same topic.
The pub/sub messaging model in JMS includes an in-process Java event model for handling incoming messages. This is similar to the event-driven model used by Java beans.[3] An object simply implements the listener interface, in this case the MessageListener, and then is registered with the TopicSubscriber. A TopicSubscriber may have only one MessageListener object. Here is the definition of the MessageListener interface used in JMS:
package javax.jms;

public interface MessageListener {
public void onMessage(Message message);
}
When the TopicSubscriber receives a message from its topic, it invokes the onMessage( ) method of its MessageListener objects. The Chat class itself implements the MessageListener interface and implements the onMessage( ) method:
public class Chat implements javax.jms.MessageListener{
…
public void onMessage(Message message){
try{
TextMessage textMessage = (TextMessage)message;
String text = textMessage.getText( );
System.out.println(text);
} catch (JMSException jmse){jmse.printStackTrace( );}
}
…
}
The Chat class is a MessageListener type, and therefore registers itself with the TopicSubscriber in its constructor:
TopicSubscriber subscriber = subSession.createSubscriber(chatTopic);

subscriber.setMessageListener(this);
When the message server pushes a message to the TopicSubscriber, the TopicSubscriber invokes the Chat object’s onMessage( ) method.
It’s fairly easy to confuse the Java Message Service with its use of a Java event model. JMS is an API for asynchronous distributed enterprise messaging that spans processes and machines across a network. The Java event model is used to synchronously deliver events by invoking methods on one or more objects in the same process that have registered as listeners. The JMS pub/sub model uses the Java event model so that a TopicSubscriber can notify its MessageListener object in the same process that a message has arrived from the message server.
The Message
In the chat example, the TextMessage class is used to encapsulate the messages we send and receive. A TextMessage contains a java.lang.String as its body and is the most commonly used message type. The onMessage( ) method receives TextMessage objects from the TopicSubscriber. Likewise, the writeMessage( ) method creates and publishes TextMessage objects using the TopicPublisher:
public void onMessage(Message message){
try{
TextMessage textMessage = (TextMessage)message;
String text = textMessage.getText( );
System.out.println(text);
} catch (JMSException jmse){jmse.printStackTrace( );}
}
protected void writeMessage(String text) throws JMSException{
TextMessage message = pubSession.createTextMessage( );
message.setText(username+” : “+text);
publisher.publish(message);
}
A message basically has two parts: a header and payload. The header is comprised of special fields that are used to identify the message, declare attributes of the message, and provide information for routing. The difference between message types is determined largely by their payload, i.e., the type of application data the message contains. The Message class, which is the superclass of all message objects, has no payload. It is a lightweight message that delivers no payload but can serve as a simple event notification. The other message types have special payloads that determine their type and use:
Message
This type has no payload. It is useful for simple event notification.
TextMessage
This type carries a java.lang.String as its payload. It is useful for exchanging simple text messages and also for more complex character data, such as XML documents.
ObjectMessage
This type carries a serializable Java object as its payload. It’s useful for exchanging Java objects.
BytesMessage
This type carries an array of primitive bytes as its payload. It’s useful for exchanging data in an application’s native format, which may not be compatible with other existing Message types. It is also useful where JMS is used purely as a transport between two systems, and the message payload is opaque to the JMS client.
StreamMessage
This type carries a stream of primitive Java types (int, double, char, etc.) as its payload. It provides a set of convenience methods for mapping a formatted stream of bytes to Java primitives. It’s an easy programming model when exchanging primitive application data in a fixed order.
MapMessage
This type carries a set of name-value pairs as its payload. The payload is similar to a java.util.Properties object, except the values must be Java primitives or their wrappers. The MapMessage is useful for delivering keyed data.
Sessions and Threading
The Chat application uses a separate session for the publisher and subscriber, pubSession and subSession, respectively. This is due to a threading restriction imposed by JMS. According to the JMS specification, a session may not be operated on by more than one thread at a time. In our example, two threads of control are active: the default main thread of the Chat application and the thread that invokes the onMessage( ) handler. The thread that invokes the onMessage( ) handler is owned by the JMS provider. Since the invocation of the onMessage( ) handler is asynchronous, it could be called while the main thread is publishing a message in the writeMessage( ) method. If both the publisher and subscriber had been created by the same session, the two threads could operate on these methods at the same time; in effect, they could operate on the same TopicSession concurrently–a condition that is prohibited.
A goal of the JMS specification was to avoid imposing an internal architecture on the JMS provider. Requiring a JMS provider’s implementation of a Session object to be capable of safely handling multiple threads was specifically avoided. This is mostly due to one of the intended uses of JMS–that the JMS API be a wrapper around an existing messaging system, which may not have multithreaded delivery capabilities on the client.
The requirement imposed on the JMS provider is that the sending of messages and the asynchronous receiving of messages be processed serially. It is possible to publish-and-subscribe using the same session, but only if the application is publishing from within the onMessage( ) handler. An example of this will be covered in Chapter 4.
________________________________________
1. Thread-specific storage is used with the Java Authentication and Authorization Service ( JAAS) to allow security credentials to transparently propagate between resources and applications.
2. The actual physical network connection may or may not be unique depending on the vendor. However, the connection is considered to be logically unique so authentication and connection control can be managed separately from other connections.
3. Although the in-process event model used by TopicSubscriber is similar to the one used in Java beans, JMS itself is an API and the interfaces it defines are not Java beans.

1. We need to customize our Delphi compiler and linker options for maximum efficiency. Furthermore, we need to familiarize ourselves with the Windows environment itself we’re targeting.
2. We must identify bottlenecks, using Turbo Profiler or another profiling or timing tool. We will examine tools to measure the number of times a statement block is executed, and several methods of timing these statement blocks. Statement blocks may be statements, but also procedures, functions, units and whole programs. We can find the performance bottlenecks using these techniques. It will turn out that even small improvements in these bottlenecks will often have more effect than big improvements in non-bottle-neck areas.
3. We should examine the data structures and algorithms of the bottlenecks found in step 2, and try to find more efficient equivalents. We will see that the largest performance improvements can come from changing algorithms and data structures. A more specific solution to a problem might be less flexible, but can often be an order of a magnitude faster!

After we performed the first four or five steps, we know for certain that the (stand-alone!) executable (EXE, DLL, OCX) is as fast as possible. Yet, this doesn’t mean that the application doesn’t need fine-tuning. Especially in a Client/Server, or N-tier (internet) environment, we need to perform additional steps to ensure maximum efficiency.
During the Delphi Efficiency session in San Diego, we’ll spend some time exploring steps 6. and 7. by building a 2-Tier database application, using TClientDataSet and Providers.

A step can fail in two ways. One way if it simply cannot be done, and another way if it doesn’t deliver the required performance result.

Step 1. Prepare!
Before we even start to think about Performance Optimization, it is time to check out the compiler options of Delphi on our development machine. Although compiler options have less impact than a bad algorithm, it can seriously slow down our code and expand our total code size.
My personal project options for Delphi 32 (Delphi 2.x and higher) are as follows (note the checked “Default”, which means that these options are now default for every new project in Delphi on my machine):
Delphi 4 Project Options

Compared to the 16-bits Delphi Project Options – Compiler page, there are a few new things. There is now an “Optimization” option. Frankly, I don’t know why we should want to have this one turned off. It only takes a fraction longer to debug) the application with and without optimization if needed.
Another change is the “Aligned record fields” option, that will align fields within records to 32-bit boundaries. In Win32 land, this field alignment means faster writing files that contain these (previously non-aligned) records. We must use the new keyword packed in these cases, to make sure the records are packed like before.

Algorithm Analysis
Algorithm analysis focuses on the run-time behavior of the algorithm in space and time efficiency. We often use the Big-Oh notation to express the running-time O(log N) if it takes only “log N” steps to perform the task at hand; like searching honestly, have you ever used binary search when looking for a person’s phone number in the phone book?). We can distinguish the following important O(N) running-time behaviors:

In practice, we’ll mostly meet algorithms with a Logarithmic, Linear, Linear-logarithmic or Quadratic behavior. An algorithm with a Big-Oh slower than quadratic is often not very practical (even quadratic is often not usable for large input sets).  Using this Big-Oh information, we can predict that an algorithm will be slower or faster than another algorithm. A Bubble Sort of O(N2), for example,

is much slower than a Quick Sort which has an average case of O(N log N). Just fill in N=1000 for a list of 1000 elements that needs to be sorted, and we’ll see that Bubble Sort will need O(1,000,000) operations, while Quick Sort can do it in

O(10,000) – the difference between one second and two minutes! For operations, we can substitute a certain amount of work that need to be done in the so-called inner loop of the algorithm.

DATABASE
xpositif(symbol,symbol)
xnegatif(symbol,symbol)
PREDİCATES
nondeterm aranan_canli(symbol)
nondeterm canli_turu(symbol)
soru_sor(symbol,symbol,symbol)
sakla(symbol,symbol,symbol)
positif(symbol,symbol)
negatif(symbol,symbol)
olgulari_sil
basla
CLAUSES
aranan_canli(cita):-
canli_turu(memeli),
canli_turu(etobur),
positif(sahiptir,sari_kahverengi_renklere),
positif(sahiptir,siyah_benekler).
aranan_canli(tiger):-
canli_turu(memeli),
canli_turu(etobur),
positif(sahiptir,sari_kahverengi_renklere),
positif(sahiptir,siyah_seritli).
aranan_canli(zurafa):-
canli_turu(tirnakli),
positif(sahiptir,uzun_boylu),
positif(sahiptir,uzun_bacaklı),
positif(sahiptir,siyah_benekler).
aranan_canli(zebra):-
canli_turu(tirnakli),
positif(sahiptir,siyah_seritli).
aranan_canli(devekusu):-
canli_turu(kus),
negatif(eylem,ucar),
positif(sahiptir,uzun_boylu),
positif(sahiptir,uzun_bacaklı),
positif(sahiptir,siyah_beyaz_renk).
aranan_canli(penguen):-
canli_turu(kus),
negatif(eylem,ucar),
pozitif(eylem,yuzer),
positif(sahiptir,siyah_beyaz_renk).

aranan_canli(albatros):-
canli_turu(kus),
pozitif(eylem,iyi_ucar).
canli_turu(memeli):-
positif(sahiptir,tuylu).
canli_turu(memeli):-
positif(eylem,sut_verir).
canli_turu(kus):-
positif(sahiptir,kus_tuyleri).
canli_turu(kus):-
positif(eylem,ucar),
positif(eylem,yumurtlar).
canli_turu(etobur):-
positif(eylem,et_yer).
canli_turu(kus):-
positif(sahiptir,sivri_dislere),
positif(sahiptir,pencelere),
positif(sahiptir,patlak_gozlere).
canli_turu(tirnakli):-
canli_turu(memeli),
positif(eylem,gevis_getirme).
positif(X,Y):-
xpositif(X,Y),!.
positif(X,Y):-
not(xnegatif(X,Y)),
soru_sor(X,Y,evet).
negatif(X,Y):-
xnegatif(X,Y),!.
negatif(X,Y):-
not(xpositif(X,Y)),
soru_sor(X,Y,hayir).
soru_sor(X,Y,evet):-
!,
write(X,”aranan canlı:”Y’\n’),
readln(Cevap),nl,
fontchar(Cevap,’e’,_),
sakla(X,Y,evet).
Soru_sor(X,Y,hayir):-
!,
write(X,”aranan canlı:”Y’\n’),
readln(Cevap),nl,
fontchar(Cevap,’h’,_),
sakla(X,Y,hayir).
sakla(X,Y,evet):-
assertz(xpositif(X,Y)).
sakla(X,Y,hayir):-
assertz(xnegatif(X,Y)).
olgulari_sil:-
write(“\n\nBitirmek icin space tusuna basiniz\n”),
retractall(_dbasedom),readchar(_).
basla:-
aranan_canli(X),!,
write(“\n Aradiginiz canli bir “,X,” olabilir.”);
nl,nl,olgulari_sil.

basla:-
write(“\n Aradiginiz canliyi bulmak mumkun degil\n\n.”);
olgulari_sil.

Ağ üzerinde bir istemcinin sunucudaki veritabanına erişebilmesi için, sunucuda bir ağ servis adının(Net Service Name) ve bir dinleyicinin(LISTENER) oluşturulması gerekir. Oracle Enterprise Edition ile birlikte gelen Net8 Assistant ile bu gerçekleştirilebilir. Ağ servis adları, veritabanı gibi bir servisi ağda tanımlamak amacıyla basit bir yöntem olarak kullanılır.
Aşağıda Ne8 Assistant görüntüsü verilmiştir. Verilen şekilde ağ erişimi oluşturmak için gereken işlemler oldukça basittir.

SQL*Net
SQL*Net Net8’in yardımcı programıdır. Bir istemci bilgisayara Oracle Forms ürününün yüklendiğini düşünelim. Bunun için istemci bilgisayar SQL*Net ile oluşturulan veritabanı takma adını(alias) kullanır. Yukarıda Net8 konfigürasyonunun istemci bilgisayarlarda da yapılması gerektiğini söylemiştik. İşte bu konfigürasyon istemci bilgisayarlarda SQL*Net sayesinde yapılır. Burada veritabanına verilecek takma isim, protokol adı, ana bilgisayar adı (veritabanının bulunduğu) ve veritabanının SID olarak girilen ismi bilgileri girilerek düzenleme yapılır.

Oracle8i Enterprise Edition ve Gerekli Donanım
Bu rapor Oracle8i Enterprise Edition for Windows NT Release 8.1.5 sürümü üzerine düzenlenmiştir. Oracle8i Enterprise Edition CD’sinde üç farklı ürün yer almaktadır:
• Oracle8i Enterprise Edition (Server)
• Oracle8i Client
• Oracle Programmer

Oracle8i Enterprise Edition(Windows NT)

Yükleme Türü Açıklama
Typical Tam anlamıyla bir veritabanı kullanmak isteyenler için tavsiye edilen yükleme türüdür. Bir başlangıç veritabanı, ağ servisleri, Oracle yardımcı ürünleri ve yardım dokümanları yüklenir.720 MB yer kaplar. Pentium 133 ya da Pentium 166 işlemci ile kurulabilir. Önerilen işlemci Pentium 200 dür. 96 MB RAM ile çalışabilir. Tavsiye edilen bellek ise 128 MB ‘tır.
Minimal Minimum veritabanı paketi kullanmak isteyenler için önerilir. Bir başlangıç veritabanı, ağ servisleri ve bazı yardımcı ürünleri içerir. 520 MB yer kaplar. Pentium 133 ya da Pentium 166 işlemci ile kurulabilir. Önerilen işlemci Pentium 200 dür. 64 MB RAM ile çalışabilir. Tavsiye edilen bellek ise 96 MB ‘tır.
Oracle8i Client(Windows NT ve Windows 95/98)

Yükleme Türü Açıklama
Typical Veritabanı yöneticileri için veritabanına bağlanma ve veritabanı yönetim işlerini gerçekleştirme araçlarını yükler. 299 MB yer kaplar. Intel 80486 işlemci ile çalıştırılabilir. Tavsiye edilen Pentium 133 ya da Pentium 166 dır. En az 32 MB RAM ile çalıştırılabilir. Önerilen 64 MB’tır.

Oracle Programmer(Windows NT ve Windows 95/98)

Yükleme Türü Açıklama
Typical Veritabanına erişebilen geliştirme araçları ve ara yüzlerini yükler. Bu paket, ön derleyicileri(precompilers), ağ servislerini ve yardım dokümanlarını içerir. 267 MB yer kaplar. Intel 80486 işlemci ile çalıştırılabilir. Tavsiye edilen Pentium 133 ya da Pentium 166 dır. En az 32 MB RAM ile çalıştırılabilir. Önerilen 64 MB’tır.

Oracle Veritabanı Yapısı
Oracle veritabanının, işletim sistemi tarafından bakıldığında, biri fiziksel diğeri mantıksal olmak üzere iki bölümü vardır. Fiziksel bölüm, işletim sisteminden görünen kısımdır. Bunlar Data File(Veri Dosyası), Control File(Kontrol Dosyası) ve Log File(Log Dosyası) ‘dan oluşmaktadır. Mantıksal Bölüm, bir ya da daha fazla tablo uzayı(Tablespace) ve tablolar(table), görüntüler(view), sıralar(sequence), eşanlamlar(synonym), indeksler(index), kümeler(cluster), veritabanı bağlantıları (database link), prosedürler(procedure), fonksiyonlar(function), ve paketlerden(package) oluşan şema nesnelerinden oluşmaktadır. Fiziksel bölüm işletim sistemi tarafından görülebilmesine rağmen, mantıksal bölüm ancak Oracle’a bağlanıp, SQL komutları çalıştırılarak görülebilmektedir. Yani, Oracle kurulu herhangi bir makinede, SQL bilgisi olmayan bir insan, Oracle’ın sadece fiziksel bölümünü görebilmektedir.
Oracle veritabanındaki her nesnenin bir sahibi(kullanıcı olarak bahsedilir) vardır. Her kullanıcı bir veya daha fazla tablo uzayına sahip olabilir. Her nesne, ait olduğu kullanıcının herhangi bir tablo uzayında (mantıksal olarak) bulunur. Her tablo uzayı da, kendisine sahip olan kullanıcının nesnelerini tutmak için işletim sisteminde bir veya daha fazla veri dosyasına sahip olabilmektedir.
Sonuç itibariyle, veritabanındaki her nesnenin bir kullanıcısı vardır ve bu nesneler mantıksal olarak o kullanıcının sahip olduğu tablo uzaylarının herhangi birinin (hangisi olduğu komutlarla öğrenilebilir) içerisinde, fiziksel olarak da o kullanıcının sahip olduğu tablo uzayının herhangi bir veri dosyasında bulunur. Fakat, o veri dosyasının içerisine işletim sisteminden bu nesneyi bulmak için bakılamaz. Bu nesnenin sahibi ve mantıksal yeri “DML”(veri işleme dili) komutları ile bulunabilmektedir.

Fiziksel Bölüm
Fiziksel bölüm veritabanını oluşturan işletim sistemi dosyalarıdır. Bir Oracle veritabanı fiziksel olarak bir ya da daha fazla veri dosyası, iki ya da daha fazla log dosyası, bir ya da daha fazla kontrol dosyasından oluşur.
Veri Dosyaları(Data Files)
Veri dosyaları veri tabanındaki tüm verileri tutan dosyalardır. Tablo, indeks gibi mantıksal veritabanı yapılarının içerisindeki veriler fiziksel olarak veri dosyalarında tutulurlar. Bir veri dosyası kendisi için ayrılan alan dolduğunda, kendi sahip olduğu alanı artırabilecek özelliklere sahiptir. Bir ya da daha fazla veri dosyası mantıksal bir veritabanı depolama ünitesi olan bir tablo uzayını oluşturular.
Normal veritabanı işlemleri boyunca bir veri dosyası içerisindeki veriler okunur ve Oracle için ayrılan belleğe getirilirler. Örneğin bir kullanıcının veritabanındaki bir tablonun verilerine erişmek istediğini varsayalım. Eğer istenilen veriler bellekte yer almıyorsa, ancak o zaman uygun veri dosyasından okunur ve belleğe getirilirler.
Değişikliğe uğrayan veriler ya da yeni eklenen veriler veri dosyalarına hemen yazılmazlar. Sabit diske erişimi azaltmak ve böylece sistemin performansını artırmak için veriler bellek havuzunda tutulur ve gerektiğinde hepsi birden uygun veri dosyalarına kaydedilirler. Bunu Oracle artalan işlemleri belirler.
Kontrol Dosyaları(Control Files)
Tüm Oracle veritabanları kontrol dosyasına sahiptir. Bir kontrol dosyası veritabanı adı, veri dosyaları ve log dosyalarının adı ve diskteki yeri, veritabanının oluşturulma tarihi vb. veritabanı ile ilgili bilgileri tutar.
Her veritabanı oturumu açıldığında Oracle bu dosyayı kontrol ederek gerekli bilgileri alır. Eğer veritabanında fiziksel bir değişme olursa(yeni bir log dosyası ya da veri dosyası oluşturulması gibi), yapılan değişiklikler Oracle tarafından otomatik olarak kontrol dosyalarına yansıtılır.
Log Dosyaları(Log Files)
Redo Log dosyaları olarak bilinen bu dosyaların amacı veriler üzerinde yapılan tüm değişiklikleri kaydetmektir. Eğer veri dosyalarına kalıcı olarak kaydedilmiş olan, değişikliğe uğramış kayıtlarda bir bozukluk olursa yapılan değişiklikler redo log dosyalarından sağlanabilir ve işlemler kaybolmaz. Birden fazla tekrarlanan bozukluk durumlarında redo log dosyalarının da bozulmasını engellemek için Oracle farklı diskler üzerinde redo log dosyalarının birden fazla kopyasının alınmasına olanak sağlar.
Bir veritabanı işlemi sırasında elektrik kesilirse, bellekteki veriler veri dosyalarına kaydedilmeyecek ve verilerin kaybolması durumuyla karşılaşılacaktır. Oracle veritabanı tekrar açıldığında redo log dosyalarında yapılan son değişiklikler veri dosyalarına yansıtılarak verilerin kaybolması engellenir.
Mantıksal Bölüm
Oracle veritabanının mantıksal yapısı tablo uzaylarını(tablespaces), şema nesnelerini(schema objects), veri bloklarını(data blocks), genişlemeleri(extents) ve parçaları(segments) içerir.
Tablo Uzayı(TableSpace)
Bir veritabanı, ilişkili mantıksal yapıların gruplanmasını sağlayan ve tablo uzayı olarak bilinen mantıksal depolama ünitelerine bölünmüştür.

Yukarıdaki şekil veritabanı, tablo uzayı ve veri dosyaları arasındaki ilişkiyi açıklamaktadır. Buna göre:
• Bir veritabanı bir ya da daha fazla tablo uzayına bölünmüştür.
• Tablo uzayı içerisindeki tüm mantıksal yapıları fiziksel olarak depolayabilmek için, her tablo uzayı bir ya da daha fazla veri dosyasına sahip olabilir.
• Tablo uzaylarının toplam kapasitesi, sahip oldukları veri dosyalarının toplam kapasitesine eşittir.(Yukarıdaki şekil için SYSTEM tablo uzayı 2MB, USERS tablo uzayı 4MB).
• Tablo uzaylarının toplam kapasitesi veritabanının toplam kapasitesini belirler.(6 MB)
Bir tablo uzayı açık ya da kapalı olabilir. Tablo uzayı kapalı olduğunda bu tablo uzayının içerisindeki nesnelere erişilemez. Bir tablo uzayı yönetim amaçlı olarak kapalı duruma alınabilir.
Veri Tabanı Şema Nesneleri
Şema nesneleri mantıksal veri depolama yapıları olarak bilinir. Veritabanı üzerinde kullanıcının belirli işleri yapabilmesi için tanımlanan bu yapılar tablolar, görüntüler, sıralar, eşanlamlar, indeksler, kümeler, veritabanı bağlantıları, prosedürler, fonksiyonlar, ve paketlerdir. Bir şema ise bu nesnelerin oluşturduğu gruptur.

Küme(CLUSTER)
Aynı anda sorgulanan birden fazla tablonun bir arada kaydedilmesine “cluster” denir. Bu yapı, beraber sorgulanan tablolarda hız kazanmak için çok önemlidir. Örneğin “isci” tablosu ile “bolum” tablosunun(bu tabloların yapısı için SQL bölümüne bkz.) her ikisi de ortak olarak “bolum” ve “bolumno” alanlarını içermekte. Yani “isci” tablosundaki “bolum”, “bolum” tablosundaki “bolumno” alanına karşılık geliyor. Burada oluşturulacak bir cluster’da her iki tablo veritabanında yan yana getirilerek aynı veri bloğu içerisine kaydedilir.Böylece daha hızlı erişim sağlanır.
İndeks(INDEX)
İndeksler tablo ve cluster’lar için kullanılan veri tabanı nesneleridir. Burada amaç aranılan bir kayda daha hızlı erişimdir. Özellikle üzerinde çok arama yapılan alan veya alanlar üzerinde indeks oluşturmak çok etkilidir. İndeks oluşturulduğunda ilgili tablonun kayıtları yer değiştirmez. Sadece ilgili kayıtların kayıt numaraları olarak adlandırılan “rowid” ‘ler alınarak sıralama yapılır.
Bir tablo üzerinde oluşturulabilecek indeks sayısı sütunların kombinasyonları farklı olduğu müddetçe sınırsızdır. Bir sütun diğer sütunlarla değişik kombinasyonlarda kullanıldığı müddetçe birden fazla indeks içerisinde yer alabilir. Aynı sütun kombinasyonlarının indeksi, faklı indeks ismi kullanarak oluşturulmaya çalışılsa bile gerçekleştirilemez.
İndeksleme işleminin gerçekleştirilmesinde Oracle çoğunlukla B-tree indeksleme metodunu kullanır. Bunun yanında “hash cluster indexes”, “reverse key indexes”, ve “bitmap indexes” yöntemlerini de kullandığı bilinmektedir.
İndeksler mantıksal ve fiziksel olarak oluşturuldukları tablodan bağımsızdırlar. Eğer bir indeks silinirse, ilgili tablo zarar görmez, çalışmaya devam eder. Fakat indeks olmadığı için veri erişim süresi artacaktır.
Oracle bir indeks oluşturulduğunda onu otomatik olarak kullanmaya başlar ve indeksin oluşturulduğu tablodaki silme, güncelleme ve ekleme işlemleri indekse otomatik olarak yansıtılır.
Rol(ROLE)
Oracle veritabanında her nesnenin ait olduğu bir kullanıcı vardır. Bir kullanıcı bir başka kullanıcının nesneleri üzerinde işlem yapmak isterse buna hakkı olması gerekir. Bir nesne üzerinde işlem yapabilme yetkisine hak denir. Örneğin veritabanına bağlanma, tablo oluşturma, bir başkasına ait tablodan kayıt listeleme, bir başkasının prosedürünü çalıştırma birer haktır. Bu haklar kullanıcılara atanmak suretiyle kullanıcıların bu işlemeleri gerçekleştirmeleri sağlanır. Hakların kullanıcılara atanması iki şekilde olabilir. Birinci olarak bir tabloya kayıt ekleme, kayıt silme vb. haklar bir kullanıcıya ya da kullanıcılara ayrı ayrı atanır. İkinci şekilde ise verilmek istenen haklar bir rol altında birleştirilir ve bu rol istenen kullanıcılara aktarılır.
Haklar “sistem hakları” ve “nesne hakları” olmak üzere ikiye ayrılır. Sistem hakları veritabanı ile ilgili olarak önceden tanımlanmış rollerdir. Oracle’da 60’tan fazla sistem hakkı tanımlanmıştır. Nesne hakları ise veri tabanı nesneleri üzerinde işlem yapma haklarıdır. “Create Table”, “Create TableSpace”, “Drop Any Index” gibi haklar sistem haklarına örnek olarak verilebilir. Nesne hakları ise 8 çeşittir. “Select”, “Insert”, “Update”, “Delete”, “Alter”, “Index”, “Execute”, “References”, “All” çeşittir. “All” ayrı bir hak olarak adlandırılmaz. Diğer tüm hakları kapsar. Bu haklar sırayla kayıt seçme, kayıt güncelleme, kayıt silme, nesnelerin yapısını değiştirme, indeks oluşturma, alt program çalıştırma, yabancı anahtar tanımlayabilme işlemlerini içerirler. Rol tanımlama ve hak verme komutları ileride ayrıntılı olarak işlenecektir.
Geri Alma Parçası(ROLLBACK SEGMENT)
Oracle veritabanının güvenliği açısından “Select”, “Insert”, “Update”, “Delete” gibi işlemlerin yedeğini almaktadır. Alınan bu yedeklerin konulduğu yerlere geri alma parçası denir. Kullanıcı bu tip işlemleri yaptıktan sonra “Rollback” komutunu uygularsa, yaptığı değişiklikler geri alma parçalarından getirilir ve böylece kayıtlar eski haline dönmüş olur. Kullanıcı “Commit” komutunu verirse yaptığı değişiklikler geri alma parçalarından geri getirilemez. Her veritabanında bir ya da birkaç tane geri alma parçası olabilir.
Sıra(SEQUENCE)
Tablolardaki kayıtlar için otomatik sıra numarası verilmesi isteniyorsa sıra nesnesi kullanılabilir. Bu sıra numarası veritabanı tarafından otomatik olarak üretilir. Özellikle çok kullanıcılı ortamlarda tekil olarak numara üretilmek istendiğinde çok kullanışlıdır. Birden fazla kullanıcı aynı anda böyle bir sayı üretmek isterse bunun program koduyla yapılması işlem hızını yavaşlatır. Çünkü bir kullanıcı diğeri işini bitirene kadar beklemek zorundadır. Sıra nesnesi bu işi otomatik olarak ve çok seri bir şekilde başarır.
Sıra numaraları Oracle’da tanımlı 38 rakama kadar tamsayılardan oluşur. Bir sıra tanımlaması sıranın adını, artan ya da azalan olacağını, iki sayı arasındaki fark miktarını içerir. Oracle tüm sıra numarası tanımlarını SYSTEM tablo uzayının içerisindeki bir veri sözlüğü tablosuna kaydeder. SYSTEM tablo uzayı sürekli çalışır durumda olduğu için tüm sıra numaraları da aktiftir. Sıra numaraları tablolardan bağımsız olarak üretilir. Yani bir sıra numarası bir ya da daha çok tablo için kullanılabilir.

Kayıtlı Fonksiyonlar(STORED FUNCTION) ve Kayıtlı Prosedürler(STORED PROCEDURE)
Bir grup SQL ya da PL/SQL komutunun belli bir işi gerçekleştirmek için bir araya getirilip veritabanına kaydedilmesi kayıtlı prosedürler ve fonksiyonlar sayesinde olur. Birden fazla uygulama programı içerisinde aynı işi yapan kodları sürekli yazmak yerine kayıtlı prosedür ve fonksiyonlar bir kere yazılır ve tüm uygulamalar tarafından kullanılır. SQL*Plus, Oracle Forms ya da Oracle Reports içerisinden bu prosedürler çağrılabilir. Prosedürler geriye birden fazla değer döndürebilirken, fonksiyonlar sadece bir değer döndürürler.
Eşanlam(SYNONYM)
Eşanlam bir tablo, görüntü, sıra, prosedür, fonksiyon ya da paket için “alias” olarak adlandırılan bir takma isimdir. Eşanlam bir takma isim olduğu için veri sözlüğü içerisindeki tanımının kapladığı yer haricinde, veritabanında yer kaplamaz. Eşanlamlar güvenlik ve daha rahat kod yazma amacıyla kullanılırlar. Bir eşanlam kullanıldığında ilgili nesnenin adı ve sahibi gizlenir ve SQL komutu içerisinde kullanımı kolaylaşır.
Eşanlamlar genel(Public) ve özel(Private) olarak tanımlanabilirler. “Genel” olarak tanımlanan eşanlamlara tüm veritabanı kullanıcıları erişebilir. “Özel” olarak tanımlanan eşanlamlara sadece ilgili nesnenin sahibi ve sahibi tarafından hak verilmiş bir başka kullanıcı erişebilir.
Bir nesnenin adı değiştirilmek istendiğinde ya da silinmek istendiğinde, bu nesneyi kullanan tüm uygulama programları değiştirilmek zorundadır. Oysa ki bu nesnenin bir eşanlamı oluşturulursa ve uygulama programları bu eşanlamı kullanırsa, eşanlam üzerinde yapılacak değişikliklerle bu silme vb. işlemlerden uygulama programlarının etkilenmesi önlenebilir.
Bir kullanıcı bir başka kullanıcının nesnesini kullanmak istediğinde “kullanıcı_adı.nesne_adı” şeklinde bir yazım kuralına uymak zorundadır. Eğer bir “genel” olarak bir eşanlam tanımı yapılırsa tüm kullanıcılar direk eşanlam ismini kullanarak işlemlerini gerçekleştirebilirler.
Tablo(TABLE)
İlişkisel Veri Tabanı Yönetim Sistemleri’nde veriler tablolar içerisinde yer alır. Her tablo bir isimle tanımlanır ve her biri bir “kayıt” olarak adlandırılan satırlar ile bu kayıtlardaki verilerin özelliklerini belirleyen sütunlardan oluşur. Her tablo bir ya da daha fazla sütuna sahip olabilir. Her sütunun bir adı ve veri tipi vardır.
Bir tablo oluşturulduğunda Oracle verileri depolamak için bir tablo uzayı içerisinde bir veri segmenti ayırır. Veri segmentinin değerleri değiştirilerek bir tablo için ayrılacak yer miktarı da değiştirilebilir.
Görüntü(VIEW)
Görüntü bir ya da birkaç tablodan istenilen alanların alınmasıyla oluşturulan sanal bir tablodur. Görüntü bu tablolar üzerinde gerçekleştirilen bir sorgu sonucu oluşturulur. Bir görüntü üzerinde silme, güncelleme gibi işlemler yapılamaz. Çünkü görüntü oluşturulduğu tabloların sadece o anlık görüntüsüdür ve veritabanında kendi tanımının kapladığı yer haricinde yer kaplamaz.

Oracle8 : Veri Tabanı Yönetim Sistemi, günümüzün dinamik çalışma grubu çevrelerinden yüksek hacimli ‘ online transaction’ ve sorgulama bazlı veri ambarı sistemlerine kadar uzanan geniş bir yelpazede en uygun, en iyi performansa ulaşmak için esnek, açık, ölçeklenebilir, bağımsız, güvenli bir ortam yaratan, Web-enabled uygulama yaratımını destekleyen ve kolay kullanılabilir yönetim araçları içeren güçlü bir veri tabanı yönetim sistemine sahiptir. Oracle VTYS, 130’dan fazla donanım üzerinde (UNISYS, IBM, DEC, HP, SUN, MAC, Sequent, PC, Mainframe…..) ve tüm işletim sistemlerinde çalışmakta, değişik performans ihtiyaçları için tek işlemcili donanımlar’dan, Simetrik Çoklu İşlemcili sistemler üzerinde çalışabilmektedir
Oracle’ın Kominikasyon Aracı, SQL*Net ürünü, client/server ve server/server Oracle veri iletişimini gerçekleştir. SQL*Net, yagın Kullanılan Tüm İletişim Protokollerini Destekler : TCP/IP, OS, APPLETALK, XODIAC,ve diğerleri
Oracle8 VTYS’nin mimarisi yüksek performans sağlayacak bütün teknolojileri kullanmaktadır:

Contention-Free Queries: Oracle8 VTYS’de sorgulamalar güncelleştirmeleri ve güncelleştirmeler sorgulamaları bloke etmediği için işlemler birbirlerini beklemek zorunda kalmazlar.
Paylaşımlı Derlenmiş SQL: Oracle VTYS, OLTP ortamlarda olduğu gibi çok sayıda kullanıcının aynı grup SQL cümlelerini kullandığı durumlarda bu kullanıcıların SQL cümlelerinin derlenmiş ve ortak bellekte tutulan tek bir kopyasını paylaşmalarına olanak verir. Bu shared compiled SQL yapısı sayesinde hem bellek kullanımı azalır hemde performans artar.
On-line Backup/On-line Recovery: Oracle VTYS, OLTP aktivitenin en yüksek olduğu zamanlarda bile kullanıcıları etkilemeyecek şekilde on-line backup (yedekleme) ve on-line recovery (kurtarma) işlemlerini gerçekleştirebilmektedir.
Otomatik Sıra Numarası Üretimi: Oracle VTYS, veri tabanında sıra numaraları üretilirken herhangi bir tablonun kilitlenmesine gerek olmadığından bu açıdan bir performans darboğazına girmemektedir.

Oracle, veri tabanı kaynaklarına, tablolarına ve verilerine yetkisiz ve kaçak erişimi engellemek ve denetleyebilmek ayrıca DDL komutlarının (create, select, delete vb) kullanım haklarının denetlenmesi için rol bazında güvenlik yöntemini kullanmaktadır. Bu yöntem her kullanıcının her tablo için erişim hakkının sisteme girilmesini gerekli kılan klasik yaklaşıma göre çok daha düşük maliyet getirmektedir. Oracle8 VTYS, güvenlik ve gizlilik nedeniyle erişim ve güncelleştirme için değişik şifrelerle korunma sağlamaktadır. Veri tabanı objelerine erişim yetkileri roller bazında tanımlanabilir (role-based security). Oracle8 VTYS, ANSI/ISO SQL3 güvenlik standardını desteklemektedir.

Rol, bir iş grubunu temsil eder. Veri tabanı kullanıcılarına daha önce tanımlanmış roller verilir. Böylece kullanıcının bulunduğu iş grupları kendisine verilen rollere bağlı olarak tanımlanmış olur. Bir role verilebilecek veri tabanı objelerine değişik erişim yetkileri verilebilir.
Oracle VTYS veri tabanı bütünlüğüne (Integrity) sahiptir. Bir alan üzerinde verilebilecek kısıtlama sayısında herhangi bir limit yoktur. Oracle VTYS veri tabanı bütünlüğüne ilişkin bilgiler aşağıda verilmiştir

Oracle Veri Bütünlüğü Uygulatımı
Oracle VTYS, veri bütünlüğü kurallarının herbirini tanımlamaya ve uygulamaya olanak sağlar. Bu kuralların büyük bir kısmı, bütünlük kısıtlamaları kullanılarak tanımlanır. Bütünlük kısıtlamaları aşağıda sunulmuştur;

Bütünlük Kısıtlamaları (Integrity Constraints)
Bir bütünlük kısıtlaması, bir tablonun bir kolonu için bir kural tanımlamanın bildirimsel (declarative) bir yöntemidir. Bir bütünlük kısıtlaması, Oracle VTYS tarafından veri tabanının temel tablolarına geçersiz veri girişini engellemekte kullanılan bir mekanizmadır. Bütünlük kısıtlamaları, bir veri tabanındaki bilgiler ile ilgili iş kurallarını uygulatmak amacıyla tanımlanabilir. Eğer bir ifade, yürütümünün sonuçlarından herhangi biri bir bütünlük kısıtlamasını ihlal ederse, ifadeye ilişkin değişiklikler ortadan kaldırılır (rollback) ve bir hata kodu döndürülür.
Veri tabanı idarecisinin ya da uygulama geliştiricisinin kolon değerlerinin girdisi üzerinde sınırlamalar koymak için kullanabileceği çeşitli veri bütünlüğü kısıtlamaları vardır.
Oracle VTYS tarafından desteklenen bütünlük kısıtlamaları şunları içerir:
NOT NULL Default olarak, bir tablodaki kolonların tümü “null” değere olanak verir. Yani o kolonlara veri girilmesi zorunlu değildir. Bir NOT NULL kısıtlaması, bir tablonun bir kolonundaki null değere izin verilmemesi anlamına gelir. Örneğin, A tablosundaki her kayıt için, B kolonuna, mutlaka bir değerin girilmesini gerektiren bir NOT NULL kısıtlaması tanımlanabilir.
UNIQUE Anahtar Bir UNIQUE anahtar kısıtlaması, bir tablo içinde belirlenen bir kolon ya da kolon seti içinde yinelenen değerlerin olmamasını sağlar. UNIQUE anahtar kısıtlamasının tanımına dahil edilen kolon ya da kolon seti UNIQUE anahtar olarak adlandırılır. Eğer söz konusu UNIQUE anahtar kısıtlaması birden fazla kolondan oluşuyorsa, kısıtlama karma unique anahtar (composite unique key) olarak adlandırılır.
BİRİNCİL (PRIMARY) Anahtar Bir veri tabanı içindeki her tablo, tek bir BİRİNCİL ANAHTAR kısıtlamasına sahip olabilir. Bir tablonun kayıtları, BİRİNCİL ANAHTAR bütünlük kısıtlaması ile yönetilen değerleri kullanarak tanımlanabilir ya da referans edilebilir. BİRİNCİL ANAHTAR’ın bütünlük kısıtlaması, Oracle VTYS uygulamalarına şunları garanti eder:
Bir kolonun hiçbir iki kaydı belirlenen kolon ya da kolon seti içinde yinelenen değer içermeyecektir. Birincil anahtar kolonu/kolonları null değerlere izin vermeyecektir (yani, her kayıtta birincil anahtar kolonları için bir değer olmalıdır).
YABANCI (FOREIGN) Anahtar Oracle, aşağıdakiler dahil olmak üzere referans bütünlüğü işlemleri tanımlama amacına yönelik YABANCI ANAHTAR bütünlük kısıtlaması kullanımını desteklemektedir:

Referans Bütünlüğü Kısıtlamaları Tarafından Tanımlanan İşlemler
Referans bütünlüğü kısıtlamaları, referans verilen ana anahtar değerinin değiştirilmesi durumunda, bir alt tablo içindeki bağımlı kayıtlar üzerinde gerçekleştirilen özel işlemleri de belirler. Oracle VTYS’in YABANCI ANAHTAR bütünlük kısıtlamaları ile desteklenen referans işlemleri şunları içerir: GÜNCELLEŞTİR (UPDATE), SİLMEYİ KISITLA (DELETE RESTRICT) ve BASAMAKLI SİL (DELETE CASCADE)
Basamaklı Silme (Cascading Deletes) Basamaklı silme işlemi, referans edilen ana anahtar değerlerini içeren kayıtlar silindiğinde, bağımlı yabancı anahtar değerlerine sahip alt tablolardaki tüm değerlerin de silineceğini belirtir. Örneğin, eğer ana tablodaki bir kayıt silinirse, bu kaydın ana anahtar değeri alt tablo içindeki bir ya da birden çok yabancı anahtar değeri tarafından referans alınmışsa, alt tablo içinde ana anahtar değerini referans alan kayıtlar da alt tablodan silinir.

Oracle8 VTYS, bir tablonun veri dağılımı ve saklama indekslere ve istatistiklere dayanarak SQL ifadeleri için otomatik olarak bir yürütme planı seçmektedir. Bu özellik, otomatik maliyet-esaslı eniyileyici (Cost-based optimizer) olarak adlandırılmaktadır. Kullanılan istatistikler arasında tablo ebatı, kolonların seçiciliği, verilerin indekslenen değerlerin etrafında fiziksel olarak kümelenme derecesi, vb. yer almaktadır. En etkin erişim yolunu seçerek, sorgulamanın performansını, sorgulama cümlesinin yazılım şeklinden (sözdiziminden) bağımsız hale getirmektedir. Tabloları birleştirme (join) ya da tablo erişim yolu gibi noktalarda eniyileyicinin kararlarını yönlendirmek için, SQL ifadeleri içinde bulunan ve kullanıcı tarafından verilen ipuçları kullanılmaktadır. Oracle8 VTYS’nin cost-based optimizer’ı istatistik oluştururken verinin uniform olduğunu farz etmemektedir.
Oracle veri tabanı ailesi ilişkisel mimarinin yanı sıra, nesne yönetimli teknolojiyi de tamamen destekleyen bir mimariye sahiptir. Endüstri eğilimi ve beklentileri sonucunda Oracle hem ilişkisel hem nesnesel mimariyi; paralellik, devamlılık güvenlik, ölçeklenebilirlik, kolay yönetilebilirlik, yüksek performans ve yeni veri tipleri ile birleştirerek bilgi çağında yarattığı devrimin yanı sıra evrensel bir yaklaşım sunmaktadır
Oracle8 ORDBMS, standart veri tipleri dışında kullanıcı tarafından tanımlanmış veri tipleri kullanımına imkan vermektedir. Kullanıcı tarafından tanımlanan veri tipleri ile gerçek nesnelerin modellenmesi mümkün olmaktadır. Bu amaçla Oracle, SQL3 standartları çerçevesinde SQL diline ekler getirmektedir

Kompleks veri nesnelerinin modellenmesi amacıyla, Oracle8 yeni veri tipleri ile veritabanını genişletmek (user-defined veri tipleri) imkanı sunmaktadır. Bu yapı altında; Harici prosedürlerde Object veritipleri tanımlanması, Index-only tablolar, Nested tablolar, Array veri tipleri tanımlanabilmektedir.
Oracle8, mevcut ilişkisel veriler üzerinde Object View’ler yaratarak, ilişkisel ve object (nesne) verilerin bir arada kullanılmasına olanak verir
Hükümet ve ticari güvenlik ihtiyaçlarını karşılamak amacıyla çok seviyeli güvenlik yaklaşımını destekleyen Oracle veri tabanı ailesinin kişisel bilgisayar ihtiyaçlarına da karşılık veren aynı kernel’e sahip versiyonu mevcuttur.
Ne
twork Computing Architecture (NCA)’ın anahtar bileşeni olan Oracle8 Enterprise Edition, network-merkezli bilgisayım ve nesne geliştirim yöntemlerinin peformansını, güvenilirliğini ve ölçeklenebilirliğini karşılamak üzere tasarlanmıştır. İster geleneksel şirket uygulamaları ister Web üzerinde elektronik ticaret olsun Oracle8 Enterprise Edition ve NCA; en çok gereksinim duyulan uygulamalara destek vermek üzere performans, güç, network bütünleşmesi ve esneklik sağlar.

Veri depolama uygulamaları, yüklü miktarda veri ile çalışan karmaşık, anlık sorgulamalara bağlı olarak OLTP uygulamalarından daha farklı işleme tekniklerine gereksinim duyarlar. Bu özel gereksinimleri karşılamak üzere Oracle8 çok çeşitli sorgu işleme teknikleri, veri erişim yolunu seçmek üzere incelikli sorgu optimizasyonu ve paralel donanım konfigürasyonundan tam anlamıyla yararlanan ölçeklenebilir bir mimari sunmaktadır.

Oracle8 ile geliştiriciler ve son kullanıcılar fiziksel olarak dağıtımlı veritabanını tek bir mantıksal veritabanı olarak ele alırlar ve dağıtımlı ağ ortamındaki her türlü veriye tek bir lokal makina üzerindeymişçesine erişim sağlarlar ve verinin güncellemesini aynı kolaylıkla yerine getirirler. Üretim uygulamaları da çoklu sistemler üzerine dağıtılabilir.
Personal Oracle8, Oracle8 veritabanının masaüstü sürümü olup yeni sezgisel kullanıcı arabiriminin yanı sıra ileri veri kopyalama özellikleri sunmaktadır.

Personal Oracle8 üzerinde geliştirilen uygulamalar yeni yapılandırmaya gerek kalmadan diğer Oracle8 platformlarında da çalışmaktadır. Personal Oracle8 istemci/sunucu uygulamalarında ideal geliştirim platformudur. P O 8 sayesinde ;
Veritabanı nesnelerini yönetebilirisiniz. Tablo verisi izleyebilir ve düzenleyebilirsiniz. Uzaktaki çoklu bağlantıları yönetebilirsiniz. Otomatik veri uyumu konfigürasyonu yapabilirsiniz.

Personal Oracle Lite bir megabyte bellekten daha azına sığabilen tek kullanıcılı nesne-ilişkisel veritabanıdır.. Personal Oracle Lite az yer kaplayan aygıtlarda tek kullanıcılı, küçük çaplı uygulamalar geliştirmek isteyenler için ideal bir yazılımdır.
Personal Oracle Lite çalışma grupları ve şirketler için kullanılan Oracle veritabanıyla veri kopyalanmasını desteklemektedir. İstemci veritabanı altında kullabılmak üzere geliştirilmiş mükemmel bir gömülü veritabanıdır (embedded database) 1MBtan az bellekten daha azına gereksinim duyan Oracle Personal Lite hem hafif hem de çok güçlüdür. Bu sayede uygulamalar çok az bellek kaynağı gerektirirken istemci veritabanı kullanmanın avantajlarına da sahip olurlar. Personal Oracle Lite SQL nin set-tabanlı ilişkisel özelliklerinin gücünü karmaşık veri temsili birleştirir ve C++ gibi nesne-yönelimli programlama dillerinden doğrudan dolaşma (navigation) erişimine izin verir. Personal Oracle Liteın sahip olduğu bu nesne teknolojisi yeni kuşak Oracle nesne yönelimli araçların, bağlanırlığın ve sunucu ürünlerinin tamamlayacaktır.

Oracle ConText option, Oracle8 ilişkisel veritabanınızın bütün gücünü kullanarak, metin bilgi kaynaklarını yapısal verilerde olduğu kadar kolay ve hızlı kullanımına olanak veren metin yönetimidir. Haber arşivlerinden önemli Web içeriklerine kadar her tür bilgi kaynağına ulaşım ve yönetim için idealdir

The Oracle Video Option, kullanıcıların firma ağı üzerinden istemcilere gerçek zamanlı, tam ekran video ve yüksek kaliteli seslerin saklanması, yönetimi ve kullanımına çözüm sağlayan yazılımdır. Oracle8 Server’a opsiyon olarak Oracle Video Option geleneksel veri modelini yüksek kalitede ses ve video kullanarak geliştirir.

Oracle Advanced Networked Option, firma dizin hizmetleri, tek oturumla açılan hizmetler, network şifreleme, jeton ve kullanıcının biyometrik doğrulanması sayesinde tek kaynaklı bütünleşme ve Oracle8nin OSF Distributed Environmet (DCE) ile birleşimine olanak verir
Oracle değişik bireysel teknolojiler kullanılarak bu tür hizmetler sağlamanın bir çok yolu olduğunun bilincindedir. Advanced Networking Option her bir hizmetin yürütülmesinde bir çok yol sunan “tabii teknoloji”dir. Bunun sonucunda, ağ ortamlarına ve güvenlik yazılımlarına yaptığınız yatırımları korurken, yeni teknolojileri de çıktıkça sisteminize katabilirsiniz.

ORACLE UYGULAMA GELİŞTİRME ARAÇLARI
Oracle’ın ölçeklenir uygulama geliştirim çözümü içerisinde iki ürün grubu yer almaktadır: Oracle Designer/2000 ve Oracle Developer/2000™. designer/2000™ iş süreci yeniden yapılandırması (BPR), analiz ve tasarım diyagramcıları ile karmaşık sistemlerin modellenmesine destek verir.
Developer/2000 organizasyonların iş gruplarından şirketlere, çeşitli ölçeklerde, hızlı ve üretken bir biçimde incelikli sistemler üretmelerini sağlar. Ortak bir depo, esnek modelleme ve yöntembilim desteği ve portatif açık mimari sayesinde Designer/2000 ve Developer/2000 endüstrinin tek ikinci kuşak istemci/sunucu ve geliştirim araçlarıdır.

Üretkenlik
Developer/2000in güçlü bildiri yeteneği kullanılarak veritabanı tanımlamalarından, tek bir kod satırı yazmadan, uygulama yaratımı gerçekleştirilebilir.
İstemci/Sunucu Ölçeklenirliği
Ölçkelenirlik Developer/2000 geliştiricileri için oldukça basit bir işlemdir, çünkü ürünün mimarisi içerisinde bu özellik içsel olarak mevcuttur. Dizi getirme, veritabanı imleçleri, bağ değişkenleri, kayıt noktaları ve sıralar olarak sunucu işlevselliği paralel olamayan desteğinde belirtilmiştir
Taşınabilir Olma
Taşınabilir olma ve küresel yaygınlaştırım Oracle ürünlerinin ticari markalarıdır.
Birleşik İstemci/Sunucu Düzenleme ve Hata Ayıklama
Developer/2000 uygulamalarınızın özgün hale getirilmesi sunucu nesnelerinizin değiştirilmesi kadar kolaylaşmıştır.
Tam Bir GUI Desteği
Developer/2000, Windows, Macintosh ve Motif üzerinde doğal bir biçimde taşınanbilir uygulamalar ve character mode sağlar.
Model Yöneltimli Geliştirim
Geliştiriciler depo tanımlamalarından tam bir Developer/2000 uygulamasını gerçekleştririken Designer/2000 kullanmayı seçebilirler. Herhangi bir başka ürünle bu kadar karmaşık, belgelenmiş, standart hale getirilmiş, serbest kullanımlı uygulamalar yaratmanıza olanak yoktur.
Kolay Bütünleşme
Uygulamalarınızın becerilerini genişleten açık mimari sayesinde Developer/2000 esneklik garantisi vermektedir.
Takım Geliştirimi
Developer/2000 uygulamalarınız, uygulama mantığı ve kullanıcı arabirim nesnelerini paylaşabilmekte, bu sayede size takım geliştirim standartlarını tanımlama ve güçlendirme ve uygulama nesnelerini ya da kodunu bir anda yeniden kullanma olanağı vermektedir.
Türdeş Olmayan Veri Erişimi
Developer/2000 yalnızca güçlü Oracle8 veritabanı becerilerini kullanmak üzere değil aynı zamanda formatı ve konumu ne olursa olsun organizasyonunuz içerisindeki tüm veriye erişim sağlamak üzere tasarlanmıştır. DB/2, SQL Server, DB2/400, Access ve RDB dahil olmak üzere seçiminizin gerektirdiği veri kaynakları ile iletişim kurmak üzere Open Client Adapter™, Oracle Open Gateway™ teknoloji ya da uygulama programlama arabirimler (API’ler) kullanır.
Bunun yanısıra;
İlişkendirilmiş veritabalarındaki verileri yönetilen bilgilere dönüştürmeyi mümkün kılıyor. Oracle Express in güçlü olanaklarıyla doğan Discoverer, kullanıcıların tek kaynaktan tüm olası iş araçlarına ulaşmasını sağlıyor. Discoverer ın predictive query governer (tahmini sorgulama yönetimi) özelliği, bir sorgulamanın sonuçlanmasının ne kadar süreceğini bildiriyor ve sorgulamanın tamamlanması kararını kullanıcıya bırakıyor. Bu özellik, sistemi yavaşlatan çok uzun süreli taramalardan tasarruf sağlıyor.
Web yayınlama özelliği sayesinde kullanıcılar Oracle discoverer dan son raporları Web üzerinde yayınlama olanağı buluyor. Bu sayede organizasyon içinde çok fazla kişinin standart Web tarayıcısı kullanarak sonuçlara ulaşmasını sağlıyor.

Pin(9-pin) Pin(25-pin) Signal Source Type Description
1 8 CD DCE Control Carrier detect
2 3 RD DCE data Received data
3 2 TD DTE data Transmitted data
4 20 DTR DTE control Data terminal ready
5 7 GND - - Signal ground
6 6 DSR DCE control Data set ready
7 4 RTS DTE control Reguest to send
8 5 CTS DCE control Clear to send
9 22 RI DCE control Ring Indicator
- 1, 9-19, 21, 23-25 unused - - -
Cross Bağlama: İki bilgisayarı seri portlarından bağlarken kablolar cross bağlanmalıdır. Cross bağlarken seri portun birinin alan pini(received data) diğerinin gönderen(transmitted data) pinine karşılık gelecek şekilde bağlanmalıdır. Groundları(toprakları)ortak bağlanır.CTS ve RTS sinyallerini biz projemizde kullanmadık.Çünkü iki bilgisayar haberleşirken bu sinyallere gerek yoktur. Bilgisayar ile diğer bir araç haberleşirken kullanılması gerekir.

DTE ve DCE
Standart, terminal ucuna veri terminal ekipmanı, DTE adını vermiştir. Modem ucu ise veri devre tamamlama ekipmanı, DCE(Data Circuit-terminating Equipment) olarak adlandırılmıştır. Linkteki hangi cihazın DTE hangisinin DCE olduğu önemsizdir. İkisinin birden olması önemlidir.Tip, konnektördeki sinyallerin hangisinin giriş hangisinin çıkış olduğunu belirler.
TD(Transmit Data), bir DTE’de çıkışken, bir DCE’de giriş olur. RD(Receive Data ) bir DTE’de giriş bir DCE’ de çıkıştır.
PC seri portları (istisnalar kaideyi bozmaz) DTE olarak yapılanmıştır. Modem seri portları ise DCE olarak belirlenmiştir. Çevre birimlerinin büyük çoğunluğu da DCE grubundadır.
2 yollu iletişimin zorunlu 3 sinyali vardır:
TD : Veriyi DTE’den DCE’ ye taşır.TX ya da TXD de denilmektedir.
RD: Veriyi DCE’ den DTE’ye taşır.(RX yada RXD)
SG: Toprak sinyali, (GND veya SGND)
Bunlar dışındaki sinyaller seçimlik kontrol sinyalleridir ve bir cihazın iletişim anındaki durumuyla veya telefon hattındaki taşıyıcı sinyalin ya da zil sinyalinin mevcudiyetiyle ilgilidir.
İki çift el sıkışma sinyali vardır: DTR/DSR ile RTS/CTS
DTR True iken veri terminali hazırdır. Kontrol eden cihaz,sinyali true yapmak için hattı yükseltir. DTR false iken veri terminali hazır değildir. Sinyali False yapmak için,hat kontrol cihazı tarafından alçaltılır.
DTE-terminal
DCE-modem
DTR/DSR el sıkışma sinyalleri modeme ulaşan telefon hattının yada diğer bir iletişim kanalının durumu hakkında bilgi verme amacını taşır. Terminal DTR’yi yükselterek modemi iletişim kanalına bağlanmaya çağırır. Buna karşılık modem de DSR’yi yükselterek bağlandığını bildirir. Modem kanala girmediyse yada bir hata varsa, DSR sinyali false olur.
Terminal RI zil sinyaline karşılık olarak da DTR’yi yükseltir ve modemin çağrıyı yanıtlamasını isteyebilir. Bazı linklerde DTR ve DSR cihazların açılmasıyla yükseltilir. Böylece cihazlar birbirlerinin durumlarından haberdar olurlar.
RTS/CTS ise cihazların veri almaya hazır olup olmadıklarına ilişkin ek bilgiler içeren el sıkışma sinyalleridir.2 yaygın kullanımları vardır:
1. Bu sinyal çifti tam el sıkışma sağlarlar. Terminal veri göndermeye hazır olduğu zaman RTS (gönderme talebi) yollar. Buna karşılık modem almaya hazır olduğunu gösteren CTS(gönderime açık) sinyalini yollar. İletişim sona erdiğinde terminal RTS’yi düşürür. Modem aldığı veriyi işlemesinin ardından CTS’yi düşürerek bir sonraki RTS’ye yanıt vermeye hazır olduğunu belirtir. RTS,False ise terminal yeni gönderim için RTS’yi yükseltmeden önce CTS’nin False olmasını beklemek durumundadır .Yarı çift yönlü bir linkte,modem yalnızca RTS’nin false olması halinde veri gönderebilir.
2. Cihazlar veri göndermeye hazır olduklarını bildirmek üzere çıkışlarını serbest bir şekilde kullanırlar. CTS’nin işlevi aynıdır: DCE’nin veri almaya hazır olduğunu gösterir. RTS farklıdır: DTE’nin alıma hazır olduğunu belirtir. Uçlar gönderime başlamadan önce birbirlerinin sinyallerine bakarlar.(kullanılan budur.)
CD (taşıyıcı algılandı) sinyali; Modem telefon hattından beklediği frekansta bir sinyal algıladığı zaman CD’yi yükselterek uzaktaki modemle bağlantının kurulduğunu belirtir.
Tüm sinyaller tarafından kullanılan toprak sinyali SG’dir.

Visual BASİC 6.0 PROJE TASARIM PENCERESİNE
BAKIŞ
Visual BASIC 6.0 açıldığı zaman karşınıza Şekil 1.1’de görülen ekran görüntüsü gelecektir.

Şekil 1.1 –Visual Basic açılış ekranı

Örnekler Standard EXE projeleri ile oluşturulacaktır. Visual basıc tasarım penceresi açıldığında göze ilk çarpan önemli özellik tasarım ortamının MDI modunda açılmasıdır.(Şekil 1.2)

5

Şekil 1.2 Visual BASIC 6.0 Proje Tasarım Penceresi

MENÜ SATIRI: 11 adet ana menü başlığı ve herbirinin alt menülerini içerir. Visual BASIC ortamında proje(yazılım) geliştirirken yararlanılabilecek çeşitli fonksiyonları vardır.

KONTROL NESNELERİ: Visual BASIC ortamına önceden yerleştirilmiş neslerdir. Bu kontrollerden gerekli olanları form üzerine taşınır ve yazılım icrası esnasında istenilen fonksiyonları yerine getirebilmeleri için bu kontrollere bağlı bilgisayar programları(kodlarcodes) da oluşturulur.

FORM: Visual basıc pojesinin temel nesnesidir. Proje ile ilşkili tüm nesneler form üzerine yerleştirilir. Bir projede, gerekiyorsa birden fazla form da bulunabilir.

PROJECT: O anda aktif formla ilişkili olarak bazı işlevleri yerine getirir. Pencere başlığının hemen altında iki guruba ayrılmış üç buton bulunur. Bunlardan View code butonu seçilirse , o
esnada aktif olan nesneye bağlı olarak oluşturulmuş bilgisayar programı(kodu) görüntülenir.
View Object butonu seçilirse de, bu durumda tasarım aşamasında o an için seçilmiş olan nesne x
görüntülenecektir.
Tolggle Folders butonu ile ise proje içinde kullanılan genel maksatlı modüller, ormlar, ınıflar ve kaynak dosyaları gibi proje bileşenleri bir dizin mantığı içinde ayrıntılı veya toplu halde görüntülenir.

ÖZELLİKLER : o anda aktif durumdaki (seçilmiş) Visual BASIC kontrolünün tüm özellikleri görüntülenir.
IMMEDIATE: breake modda (tasarım ortamında program akışının kesilmesi) otomatik olarak boş olarak açılır.Debug,reset ve komut satırındaki işlemler uygulanabilir veya program akışını kalındığı yerden devam edilebir.
LAYOUT: Formların ekrandaki pozisyonlarını mouse yardımı ile ayarlanabilir.

MENÜ SATIRI
FİLE(DOSYA) MENÜSÜ:
Şekil 1.3’deki alt menülerden oluşur.

EDİT MENÜSÜ

VİEW MENÜSÜ

PROJECT MENÜSÜ

FORMAT MENÜSÜ

DEBUG MENÜSÜ

TOOLS MENÜSÜ

ADD-INS MENÜSÜ

WİNDOW MENÜSÜ

HELP MENÜSÜ

Visual Basic (Bölüm-2) PROJELER VE BİLEŞENLERİ
Visual Basic’te bir uygulama geliştirmek proje denilen yapı içerisinde gerçekleştirilir. O halde yeni uygulama yeni bir proje oluşturmayı gerekli kılacaktır. Bir Visual BASİC Projesi,formlar,Formlar üzerine yerleştirlen kontrol nesneleri, nesnelere bağlı kodlar (event procedures-olay prosedürleri) ile bağımsız modüllerden oluşur. Visual BASİC ‘te proje dosyalarının uzantıları .max ya da . vbp şeklindedir.

Şekil 2.1’-Başlangıç Penceresi

Şekil 2.1’de görülen başlık satırı o anda aktif olan projenin adını göstermektedir.
Menü Satırı: 11 adet ana menü başlığı ve herbirinin alt menülerini içerir. Visual BASIC ortamında proje(yazılım) geliştirirken yararlanılabilecek çeşitli fonksiyonları vardır.
Araçlar Satırı: Menü içerisinde yer alan bazı işlemleri kullanıcının daha hızlı gerçekleştirebilmesi için kullanabileceği ikonları içerir. Bu ikonlardan herhangi biri üzerine götütürseniz mouse’yi bu ikonun gerçekleştireceği menü seçeneğinin ne olduğunu görebilirsiniz.

Özellikler Penceresi:O esnada ilgi odağı olan (seçilmiş, aktif)nesneye ait özellikler ve o andaki değerlerini listeler. Ekranda bu pencere yoksa View/Properties Window menü adımları ile çağırılabilir.
Proje Penceresi: o esnada aktif durumda olan proje ile ilişkili dosyaların listesini görüntüler. Bu dosyalar , projeye ait nesneler (form, kontroller vb) ya da bağımsız modüllere ait dosyalardır. Proje penceresi o esnada yoksa View/Properties Explorer menü adımları ile çağırılabilir.
Araçlar kutusu:Visual BASİC uygulamasını geliştirirken oluşturduğunuz projede kullanabileceğiniz Visual BASİC kontrol nesnelerini içermektedir. Eğer yoksa view /Toolbox menü adımları ile onu ekrana getirebilirsiniz.

ÖZELLİKLER PENCERESİ
Özellikler: penceresi, o esnada ilgi odağı olan (seçilmiş,aktif) nesnenin sahip olduğu özellikleri ve bu özelliklerin o andaki değerlerini görüntüler. Özellikler penceresini View /Properties Window menü yolu ile ya da F4 tuşuna basarak ekrana getirmek mümkündür.
Aşağıdaki özellikler penceresinin başlığı Form1’dir. Form1 başlık satırının bir alt satırında ise Form1 Form ibaresi görülmektedir.Bunun anlamı başlıklı nesnenin Form türünde bir nesne olduğudur. Özellikler penceresi bir kontrolün özelliklerini iki farklı diziliş sırasında listeleyebilir. Bunlardan ilki Alphabetic seçeneğidir. Adındanda anlaşılacağı gibi penceredeki özellikleri alfabetik olarak takip etme imkanı sağlar Categorized seçeneği ise özellikleri, Appearance (görünüş) behavior (davranış),DDE,FONT vb. bazı ortak gruplar altında listelemek için kullanılır.Özellikler penceresine dikkat edilirse, iki sütuna sahip olduğunu göreceksiniz. Bu sütunlardan soldaki özelliklerin adlarını (Caption, name, height vb), sağdaki ise bu özelliklerin o esnada sahip olduğu değerleri göstermektedir.
PROPERTİES (ÖZELLİKLER PENCERESİ)

BİR ÖRNEK PROGRAM
Visual Basic’in form penceresini Run ettiğimizde form penceresini mouse ile her tıkladığımızda “Halk Eğitimi Merkezi”yazıp bir alt satırına ‘Mouse’u iki kez tıklatın” yazmasını istiyorsak yapılacak işlem şunlardır.
1-Basit bir kod, bir procedure örneği oluşturalım .Form üzerindeyken Mouse’yi iki kez tıkla-tınız.Karşınıza Project isimli bir pencere gelecektir.Load yazan yerin (Proc kutusu)ok İşa-retini tıklatın ve oradakiDblClickseçeneğini seçip işlem satırına yazarız. Aşağıda olduğu gibi
2-Run menüsünden Start’ı seçerek kodu(projeyi)çalıştırınız.
3-Şimdi, ekran göstergesi form üzerinde iken, mouse sol tuşunu iki kez tıklatınız.

KONTROL NESNELERİ

Geliştirilen uygulamanın kullanıcı açısından kolay kullanılır ve sempatik görünümde olabilmesi için, kullanıcının uygulama ile karşı karşıya kalacağı diyalog pencerelerinin özenle tasarlanması gerekir.Kontrol nesneleri, standart kontroller ve dışardan eklenen kontroller olarak iki gruba ayrılabilir.
Standart kontrol nesneleri, Visual Basic’in yüklenmesi ile hemen kullanılabilecek olan kontrol nesneleridir.
Dışardan eklenen kontroller ise, standart nesnelerin sağladığı imkanların ötesine geçebilen, Microsoft firmasınca yada başka şirketler tarafından üretilmiş ve Visual Basic uygulamasına sonradan herhangi bir zamanda eklenebilecek nesnelerdir.
Her iki tip kontrol nesnesinin de müşterek özelliği, daha önceden kendilerine yüklenmiş belirli özelliklere sahip olmalarıdır.
FORM ÜZERİNE KONTROL NESNELERİNİ YERLEŞTİRMEK
Form üzerine kontrol nesneleri yerleştirmek, oldukça kolay olarak gerçekleştirilen bir işlemdir. Aşağıdaki şekilde gerçekleştirilir.
1)Form üzerine yerleşitirilecek olan kontrol nesnesi, mouse-click (sol tuşu bir kez tıklatma)işlemi ile araç kutusundan(Toolbox)seçilir.

2)Mouse yardımı ile, ekran göstergesi form üzerine getirilir. Mouse sol tuşu basılı tutularak mouse hareket ettirilerek kontrol nesnesinin form üzerinde arzu edilen büyüklüğe erişmesi sağlanır. Sonra mouse sol tuşu serbest bırakılır.
STANDART KONTROL NESNELERİ VE İŞLEVLERİ

GÖSTERGE

Form üzerine aktarılıp görüntülenemeyen yegane kontrol nesnesidir. Form üzerine çizilmiş bir kontrol nesnesinin boyutunu değiştirmek veya bu kontrol nesnesini hareket ettirmek gerektiği zaman yararlanılır.
RESİM KUTUSU (PİCTURE BOX)

Resim kutusu nesnesi yardımı ile form üzerinde grafikleri görüntülemek mümkündür. Ayrıca, diskinizin herhangi bir dizini içinden çağıracağınız bir bitmap, ikon(icon) ,bir resimde yükleyebilirsiniz

ETİKET(LABEL)

Etiket kontrol nesnesi, kullanıcı tarafından değiştirilemeyecek bir metni görüntülemek ya da icra esnasında uygulama tarafından değiştirilemeyecek bir metni görüntülemek amacı ile kullanılabilir.

METİN KUTUSU(TEXT BOX)

Metin kutusu kontrol nesnesi iki ayrı amaç için kullanılabilir
1)Kullanıcı tarafından, uygulamanın icrası esnasında, bilgi girişi amacı ile
2)Uygulama tarafından üretilen bilgilerin ekranda, form üzerinde görüntülenmesi amacı ile
Metin kutusunun Properties penceresinde Multiline özelliği True haline getirilmelidir.

ÇERÇEVE (FRAME)

Çerçeve nesnesi, form üzerine yerleştirilecek kontroller için görsel ve fonksiyonel anlamda bir grup oluşturma imkanı sağlar. Bu anlamda, çerçeve içine alınan kontroller, diğerlerinden kolayca ayırdedilirler.

KOMUT BUTONU(COMMAND BUTTON)

Komut butonu, kullanıcı tarafından seçildiği zaman, belirli bir işlemi yerine getirir. Bu işlem, kendisine bu olaya bağlı olarak yüklenmiş olan kod ile gerçekleştirilir. Komut butonu mouse yardımı ile bir kez tıklatma(click)işlemi gerçekleştirilebilir. Çeşitli diyalog pencerelerinde karşımıza çıkan OK ve CANCEL butonları komut butonlarına örnektir.

KONTROL KUTUSU (CHECK BOX)

Kontrol kutusu, açma ya da kapama gibi ya da seçme ve iptal gibi ikili bir kontrole ihtiyaç duyulan uygulamalarda kullanılır. Kullanıcı , belirtilen seçeneği seçerse, kutu içinde bir işaret sembolü görüntülenir. Kullanıcıya Evet/Hayır gibi seçenekler vermek için kullanılır.

OPSİYON BUTONU(OPTİON BUTTON)

Option butonları bir grup halinde kullanılırlar. Bu grup içersinde, her buton bir seçeneği temsil eder. Kullanıcı seçtiği seçeneği, ilgili opsiyon butonunu işaretleyerek belirtir.

KOMBİNE KUTU (COMBO BOX)

Bir kombine kutu, metin kutusu(text box) ve liste kutusunun (list box) özelliklerini bir araya toplar. Örneğin, kullanıcı metin kutusu gibi içine metin yazabilir ya da liste kutusu gibi, kutu içine yerleştirilmiş isimlerden istediklerini seçebilir.

LİSTE KUTUSU (LİST BOX)

Liste kutusu, kullanıcının içinden bir ya da daha fazla isim seçebileceği bir liste içerir. Listeye yeni isimler eklenebilir ya da listedeki bazı isimler çıkartılabilir. Örneğin, bir liste kutusu ile çeşitli ülke isimlerini listeleyebilirsiniz Kullanıcı bir isim seçince, o ülke isimlerini listeleyebilirsiniz. Kullanıcı bir isim seçince, o ülkenin özellikleri listelenebilir.

YATAY KAYDIRMA ÇUBUKLARI(HORİZONTAL SCROLL BARS)

Kullanıcıya, listeler içinde veya büyük miktarda bilgi boyunca yatay hareket imkanı sağlar. Bu anlamda, bir fonksiyonun değerlerinin görüntülenmesini, bir yatay hareket çubuğunun hareketi ile ilişkili olarak gerçekleştirebilirsiniz.

DÜŞEY HAREKET ÇUBUKLARI(VERTİCAL SCROLL BARS)

Düşey hareket çubukları, yatay hareket çubukları için söylenen işlemleri düşey olarak gerçekleştirirler.

ZAMANLAYICI (TİMER)

Uygulamanın çalışması esnasında, zamana bağlı olarak belirli aralıklarla, belirli eylemlerin gerçekleşmesini denetlemek amacı ile kullanılır.

SÜRÜCÜ LİSTELEME KUTUSU

İcra esnasında, geçerli sürücülerin bir listesini sunmak ve sürücüler arasında geçiş yapmak amacı ile kullanılır . Sürücü listeleme kutusu, bir dosyayı belleğe yüklemek (açmak-open)amacı ile oluşturulan bir diyalog penceresinin bir parçası olarak kullanılabilir.

DİZİN LİSTELEME kutusu(DİRECTORY LİST BOX)

İcra esnasında, aktif durumdaki sürücünün yolunu(path)ve dizinlerini (Directories)görüntüler. Bu kontrol nesnesi, kök dizinden (root directory) seçilmiş bir yolu izleyerek hiyerarşik olarak
dizin listesini görüntületmek amacı ile kullanılabilir. Aynı zamanda doğal olarak bir dosya açma diyalog penceresinin bir parçası olarak ta kullanılabilir.

DOSYA LİSTELEME KUTUSU (FİLE LIST BOX)

Verilen bir dizin içindeki tüm dosyaları listeler. Kullanıcı, listelenmiş dosyalar içinden bir dosya seçebilir. Bu kontrol nesnesi de, bir dosya açma diyalog penceresinin bir parçası olarak kullanılabilir.

ŞEKİL (SHAPE)

Tasarım (desing)zamanında görünür olan bir kontrol nesnesidir. Tasarım esnasında, form üzerine , kare,daire,elips,dikdörtgen gibi şekilleri yerleştirmek amacı ile kullanılır.

ÇİZGİ(LİNE)

Çizgi kontrol nesnesi, tasarım esnasında, form üzerine yatay, düşey ya da eğik çizgi yerleştirmek amacı ile kullanılır. Çizgi kontrol nesnesi formu parçalara ayırmak amacı ile kullanılabilir.

GÖRÜNTÜ (IMAGE )

Bir resmi görüntüleyebilen grafik tipte bir kontrol nesnesidir. Bu açıdan resim kutusuna (picture box) benzer. Fakat, resim kutusuna oranla daha az sistem kaynağı kullanılır. Mouse ile clicklendiği zaman, komut butonuna benzer özellik gösterir. Örneğin bir firma, firmanın logosunu görüntü nesnesi içine yerleştirerek, resim üzerine mouse ile click işlemi gerçek-leştirildiğinde firma hakkında bazı bilgiler listeleyen bir tanıtım yazılımı oluşturabilir.

VERİYE ERİŞİM (DATA ACCESS)

Sistemde mevcut olan veri tabanlarına erişerek, bilgi güncelleme, edit ya da bilgi görüntüleme işlemlerinin yapılabilmesine olanak sağlar.

OLE İSTEMCİSİ (OLE CLİENT)

Nesneyi bağlama ve yerleştirme yöntemi, Windows işletim sistemince kullanılan yeni bir teknolojidir. Bu teknoloji sayesinde, bir windows uygulama programı (Mesela Visual Basic 6.0) ile geliştirilen bir proje içine başka bir windows uygulama programından nesneler aktarmak mümkündür.

Visual BASİC’TE VERİ YAPILARI VE VERİ TİPLERİ

Her programlama dilinde olduğu gibi Visual BASİC’te de çeşitli veri yapıları ve veri tipleri mevcuttur. Programcının dilin imkanlarına daha iyi hakim olabilmesi için bu yapıları tanıması zorunludur.
SABİTLER(CONSTANTS)

Program içinde değeri değiştirilemeyen, çeşitli tipteki veri yapılarıdır. Örneğin
1234 şeklindeki bir sabit , Visual BASİC açısından bir tam sayı sabittir. “5666” sabiti veya “Türkiye” sabiti ise string türü sabitler, çift tırnak sembolleri içinde yazılırlar ve matematiksel işlemlere sokulmazlar.
Visual BASİC’te çoğu kez, sabitlere bir isim atanarak, program boyunca, bu isimle çağırmak ta yaygın bir uygulamadar. Bu iş için Const bildiri sözcüğüne ihtiyaç vardır.
Örn: PiSayisi=3.14159
Sabit tanımlama sözcüğünün başına private ya da Public sözcükleri konularak, sabitin sadece tanımlandığı modülde ya da tüm modüllerde tanınması sağlanabilir.
Private Const BnSabit=60
Public Const BxSabit=80
Puplic: türü bildiriler, sadece standart modüllerin General kısmında tanımlanabilir. Private sabitler ise, her tür modülün General kısmında tanımlanabilir.

DEĞİŞKENLER(VARIABLES)
Programın akışı içerisinde, değerleri sürekli olarak değişebilen veri yapısıdır.
Örneğin x=23 y=12
X=x+3 y=y+x
Bu değişkenlere yeni bir değer atanırsa , bu değişkenin öncek değeri silinecektir.

DEĞİŞKENLERE İSİM VERME
Visual Basic 6.0 değişkenlere isim vermek için aşağıdaki kurallar geçerlidir.
1-Değişken isminin ilk karakteri bir harf olmalıdır.
2-Değişken ismi oluşturulurken, diğer karakterler, harf, rakam ya da alt çizgi (-) sembolü olabilir.
3-Kullanılan harflerin küçük ya da büyük harf olmasının önemi yoktur.
4-Değişken isim uzunlukları 255 karaktere kadar olabilir.
5-Değişken isimleri içinde diğer semboller(+,-,/ ,boşluk vb)bulunmamalıdır.
ÖRNEK: Geçerli Değişken İsimleri
MAAŞ
Yaş1
NetMaaş
Genel_Toplam

Geçersiz Değişken İsimleri
1X
A-1
Brut Maaş
DEĞİŞKEN TÜRLERİ
Bu bölümde, Visual BASİC değişkenleri için kullanılabilecek veri türleri tanıtılacaktır.

INTEGER(TAM SAYI):Bir değişkenin sonunda % sembolü varsa bu değişkenin türü integer olacaktır. Integer değişkenler, bellekte 2 Byte yer kaplar ve alacakları değerler –32768 ile +32767 aralığında olabilir. Integer türü değişkenlerle daha hızlı hesaplama yapılır.
ÖRNEK Deflnt A,B
D%=5678
A=789
B=50000’ Hatalı atama
LONG INTEGER (UZUN TAM SAYI)
Sonundaki sembol & sembolü olan ya da Deflng sözcüğü ile tanımlanmış olan değişkenlerdir. Bellekte 4 byte yer kaplarlar. Alabilecekleri değerler, -2,147,483,648 ile +2,147,483,647 aralığında olabilir.
Örnek: DefLng A-C Bu örnekte, DefLng A,B veya C olan tüm değişkenler
A=234555566 Long integer olarak tanımlanmıştır.
B=567777777
SINGLE PRECISION(TEK DUYARLIKLI)
Değişkenin sonunda ! sembolü varsa, veya DefSng bildiri deyimi ile tanımlanmışsa bu değişken tek duyarlıklı tipte değişkendir. Bu tip değişkenler, bellekte 4 Byte yer kaplar. Değer aralığı negatif sayılar için –3.402823E-38 ile 3. 402823E-45 arasındadır. Pozitif sayılar içinse bu aralık 1.401298E-45 ile 3. 402823E38 arasındadır. İlk 7 haneye kadar hassastırlar.
X!=12390638.234 şeklindeki bir atamada,sonraki 8.234 kısmı yuvarlanacaktır.

DOUBLE PRECISION(ÇİFT DUYARLIKLI)
İsmi sonundaki sembol # sembolü olan ya da DefDbl bildiri sözcüğü ile tanımlanmış olan değişkenlerdir.
STRİNG(KARAKTER ZİNCİRİ)
Sonunda $ sembolü bulunan yada DefStr bildiri sözcüğü tanımlanmış olan değişkenlerdir. Genellikle metin bilgileri için kullanılır.
ÖRNEK X$=Text12.Text
CURRENCY (PARASAL FORMAT)
Değişken ismi sonundaki sembol @ sembolü olan ya da DefCur bildiri sözcüğü ile tanımlanmış olan değişkenlerdir. Ondalık noktadan önce 15 ve ondalık noktadan sonra 4 hane olacak şekilde formatlanmıştır.
DATE(TARİH)
Tarih ve zaman türündeki bilgileri saklamak için kullanılan değişkenlerdir. 1 Ocak 100 ile 31 Ocak 9999 arasındaki zamanlar için kullanılır.
ÖRNEK: DefDate T
Tar=#February 3,1996#
BYTE
Byte değişken türü, Visual BASİC 6.0 ile gelmiş bir yeniliktir. 0 ile 255 arasındaki işaretsiz tam sayıları saklamak için kullanılır.DefByte bildiri sözcüğü ile tanımlanır.

BOOLEAN
DefBool olarak tanımlanır. Sadece Doğru (True) Yanlış(False) değerlerinden birini alabilir.

VARİANT
DefVar olarak tanımlanmıştır. Bir değişken için hiçbir tip bildiriminde bilinilmamışsa, tipi Variant olarak kabul edilir. Her türlü bilgi (Date,numerik,string)yüklenebilir. Variant tipi bir değişken içine hangi tip veri yüklendiği ise IsNumeric,IsDate vb gibi kontrol edilebilir.
KULLANICI TARAFINDAN BELİRLENEN VERİ TİPİ(USER DEFINED TYPES)
Çeşitli değişkenleri bir araya getirerek bir isim altında toplamak! Elde edilen bu yeni veri tipine Kayıt(Record) adı verilir. Bir kayıt tanımlamak için önce bir kod modülünün Declarations kısmında aşağıdaki gibi bir bildirimde bulunulur:
Type PerKayıt
Sicil As Integer
Ad As String*10
Soyad As String*12
Brut As Double
Adres As String *50
End Type
Daha sonra herhangi bir form ya da modülün Declarations kısmında
Private Per As PerKayıt veya
Puplic Per As PerKayıt
Şeklinde bildirimde bulunulursa PerKayıt ile tanımlanmış bir şablon veri yapısı türünden Per adlı gerçek bir veri tanımlanmış olur.
Private per As PerKayıt
per.Sicil = 123
per.Ad = “ahmet”
per.soyad = “Caner”
TİP BİLDİRİMİ İÇİN DİM DEYİMİ
İyi bir program oluşturmak için, değişkenlerin tiplerini önceden bildirmek faydalı bir alışkanlıktır. Tip bildiriminde bulunulmazsa değişkenin tipi variant olarak kabul edilir ve gereksiz yere bellek kullanılır. Değişkenlerin tipini belirtmek için alternatif bir yol Dim deyimini kullanmaktadır;
Dim x As İnteger
Dim y As Currency
Dim z As String
DEĞİŞKEN İSİMLERİNE GÖRE TİP ATAMA
Def tipi bildirim komutları aşağıdaki örneklerdi gibidir.
ÖRNEK : DefInd A-D Bu ifade ile A,B,C,D harfleri Integer olarak tanımlanmıştır
DefDate S,T S ve T harfleri ile başlayan değişkenler Date türünden tanımlanacaktır.
PROSEDÜRLER ARASI MÜŞTEREK DEĞİŞKENLER
Bazı değişkenlerin,prosedürler arasında müşterek kullanımı gerekebilir. Bu tip müşterek kullanılabilen değişkenlere form düzeyinde veya modül düzeyinde değişkenler denir. Form düzeyinde değişken tanımlamak için, formun General,Declaration bölümüne, bu değişkenleri Dim deyimi ile yerleştirmek gerekir. Burada tanıtılan tüm örnekler bütün prosedürler tarafından kullanılacaktır.
ÖRNEK:

PRIVATE SÖZCÜĞÜ
Private sözcüğü ile, form düzeyinde değişkenler belirleyebilirsiniz. Formun General, Declaration kısmında Dim yerine Private sözcüğünü kullanarak ta değişkenleri form düzeyinde geçerli kılabilirsiniz.

Project penceresindeki Dim komutunun yerine Static komutunu yerleştirirseniz programı her RUN edişinizde rakamları unutmadan üzerine 10 koyarak toplar.
SABİT UZUNLUKLU STRİNGLER
Sabit uzunluklu string tanımlamak, bası uygulamalar için gerekli olabilir.
Dim ad As String * 8
Ad değişkeni 8 karekter uzunluğundadır.
BİRDEN ÇOK FORM İLE ÇALIŞMA
Uygulamamızın kapsamı genişledikçe, tek form üzerinde tasarım yapmak imkansız hale gelebilir. Bu durumda doğal olarak projemize yeni bir form eklememiz gerekecektir.(Form1-Form2). Bunun için Project menüsünden Add Form seçeneğini kullanmanız gerekecektir.
FORMLAR ÜZERİNDE UYGULANABİLEN METOTLAR
Bu bölümde, özellikle çok sayıda form kullanıldığında, kullanılması zorunlu olacak bazı form metotları açıklanacaktır.
SHOW METODU
Formun ekranda görüntülenmesini sağlar. Yazılış biçimi
FormAdı.Show şeklindedir.
LOAD METODU
Formu bellege yükler fakat ekranda görüntülemez. Yazılış biçimi
Load . FormAdı şeklindedir.
HIDE METODU
Formu ekrandan uzaklaştırır fakat bellekten silmez!Yazılış biçimi,
Form.Adı.Hide şeklindedir.
UNLOAD METODU
Formu bellekten siler. Bu durumda, form düzeyinde atanmış olan tüm bilgi silinecektir. Yazılış biçimi,
Unload.FormAdı şeklindedir.
Visual BASİC’te SAYILAR VE ARİTMETİKSEL İŞLEM OPERATÖRLERİ
Bir tamsayı değişkenine, bir ondalik sayı atanırsa, otomatik olarak yuvarlatılır. Örneğin,
Dim x As Integer
X=123.789 ataması sonucu x 124 değerini alır.
String türü bir bilgi numerik olarak kullanılacaksa VAL fonksiyonu ile dönüştürülür. Örneğin,
X=12*”120” ifadesinin hatalı olmasına rağmen
X=12*VAL(“120”) ifadesinin sonucu ise 1440 olacaktır .
VAL burada “120” değeri tırnak içine alındığı için karakter olarak tanınmıştır ama VAL komutu bunu sayısal bir değere çevirmiştir
STR Numerik bir ifadeyi Stringe yani karaktere çevirir. Pozitif sayıları dönüştürürken önlerine bir bşluk yerleştirilir.
ÖRNEĞİN STR(1280) ifadesinin sonucu “ 1280) stringi olacaktır.
FORMAT fonksiyonu ile, sayılar belirli bir forma dönüştürülerek görüntülenebilirler. Örneğin
S1$=Format(2457.9,”##,##0.00”) ifadesi ile S1$ stringi, “2,457.90” şeklinde
S2$=Format(876.9,”###0.00”) ifadesi ile S1$stringi,”2,457.90” şeklinde
S3$=Format(7.”0.00%”) ifadesi ile de S3$ stringi “700.00%” şeklinde olacaktır.
TARİH TÜRÜ DEĞİŞKENLERLE İŞLEMLER
Tarih türü değişkenler üzerinde de aritmetiksel işlemler tanımlanabilir. Örneğin,
Dim tar As Date print bar ifadeleri ile, tar değişkenine, bulunulan günün tarihi atan-
Dim bar As Date makta,ilk print ile bulunulan günden 7 gün önceki ve ikinci print
tar=Now ile de, bulunulan günden 7 gün sonraki günün tarihi yazdırılacak.
bar=tar-7
Print bar
Bar=tar+7

ÖRNE K Y= 3

İfadesini, x‘in klavyeden girilecek değeri için hesaplatın yazdıran bir uygulama geliştiriniz.
ÇÖZÜM
1-Form üzerine bir komut butonu yerleştiriniz. Bu butonu seçerek Properties penceresini getiriniz ve
Caption özelliğini seçerek bu özelliği HESAPLA olarak değiştiriniz.

2- komut butonu yukarıdaki pencerede belirtilmiştir.
3-Daha RUN ederek çalıştırınız. Sonuç yukarıdaki penceredeki gibidir.
BİLGİ GİRİŞ VE ÇIKIŞI KONTROL KOMUTLARI
InputBox(MESAJ) FONKSİYONU
Visual BASİC programının icrası esnasında, klavyeden bilgi girişi yapılmasını sağlayan bir fonksiyondur. Mesaj kısmı kullanılmışsa bu kısım , bilgi giriş penceresinde aynen görünecektir. Bilgi girişinde girilen bilgi string (karakter zinciri) türünde kabul edilir. Eğer nümerik olarak kullanılacaksa VAL fonksiyonu ile nümeriğe dönüştürülmelidir.

MsgBox Mesaj, Görünüm, Başlık KOMUTU
Bir programın çalışması sonucu elde edilen bazı sonuçları ya da gerekli mesajları ekrana aktarmak için kullanılır. Görünüm parametresinin kullanımı zorunlu değildir.
ÖRNEK:Bir üstde kullanılan örnek bunun için geçerlidir.
KULLANICI İLE ETKİLEŞİMLİ MESAJLAR- MsgBox() FONKSİYONU
Pekçok uygulamada, ekrana yazdırılan mesaj sonucunda kullanıcının mesajı pasif olarak izlemesinden ziyade mesaja aktif olarak cevap vermesi ve bu cevaba göre de bir işlem yapılması söz konusu olmaktadır Bu tür bir işlemi gerçekleştirebilmek için MsgBox fonksiyonu kullanılır. Fonksiyonun yazılış biçimi aşağıdaki gibidir:
Cevap%=MsgBox(Mesaj$,Görünüm%,Başlık$)

Visual BASİC 6.0 PROJE TASARIM PENCERESİNE BAKIŞ

Visual BASIC 6.0 açıldığı zaman karşınıza ekran görüntüsü gelecektir.

Örnekler Standard EXE projeleri ile oluşturulacaktır. Visual basıc tasarım penceresi açıldığında göze ilk çarpan önemli özellik tasarım ortamının MDI modunda açılmasıdır

MENÜ SATIRI: 11 adet ana menü başlığı ve herbirinin alt menülerini içerir. Visual BASIC ortamında proje(yazılım) geliştirirken yararlanılabilecek çeşitli fonksiyonları vardır.

KONTROL NESNELERİ: Visual BASIC ortamına önceden yerleştirilmiş neslerdir. Bu kontrollerden gerekli olanları form üzerine taşınır ve yazılım icrası esnasında istenilen fonksiyonları yerine getirebilmeleri için bu kontrollere bağlı bilgisayar programları(kodlarcodes) da oluşturulur.

FORM: Visual basıc pojesinin temel nesnesidir. Proje ile ilşkili tüm nesneler form üzerine yerleştirilir. Bir projede, gerekiyorsa birden fazla form da bulunabilir.

PROJECT: O anda aktif formla ilişkili olarak bazı işlevleri yerine getirir. Pencere başlığının hemen altında iki guruba ayrılmış üç buton bulunur. Bunlardan View code butonu seçilirse , o
esnada aktif olan nesneye bağlı olarak oluşturulmuş bilgisayar programı(kodu) görüntülenir.
View Object butonu seçilirse de, bu durumda tasarım aşamasında o an için seçilmiş olan nesne x
görüntülenecektir.
Tolggle Folders butonu ile ise proje içinde kullanılan genel maksatlı modüller, ormlar, ınıflar ve kaynak dosyaları gibi proje bileşenleri bir dizin mantığı içinde ayrıntılı veya toplu halde görüntülenir.

ÖZELLİKLER : o anda aktif durumdaki (seçilmiş) Visual BASIC kontrolünün tüm özellikleri görüntülenir.
IMMEDIATE: breake modda (tasarım ortamında program akışının kesilmesi) otomatik olarak boş olarak açılır.Debug,reset ve komut satırındaki işlemler uygulanabilir veya program akışını kalındığı yerden devam edilebir.
LAYOUT: Formların ekrandaki pozisyonlarını mouse yardımı ile ayarlanabilir.

MENÜ SATIRI

FİLE(DOSYA) MENÜSÜ:

New project:Yeni bir Visual BASIC projesi başlatmak amacı ile kullanılır.
Open Project:Daha önceden diskte saklamış olduğunuz bir VB uygulamasını tekrar aktif hale getirir.
Add Project:Proje penceresi birden fazla proje içerdiğinde ikinci bir projeyi ekler.
Remove Project:Aktif uygulamamız içindeki bir projeyi uygulama içinden çıkarmak için kullanılır.
Save Project Group:O esnada uygulamada kullanılan proje ve projelerle ilişkili tüm dosyaları ve ilişkili Visual BASIC bilgilerini tek bir isim altında saklamak amacı ile kullanılır. Bir kez kayıt edilince group yazısı bir daha gelmez.
Save Project Group As:Aktif çalışılan bir projeyi son hali ile diskten farklı tüm uygulama bileşenlerini yeni bir isimle saklamayı saglar.
Save (Form1)Dosya İsmi :Sadece o esnada aktif proje penceresinde seçilmiş olan bir nesneyi saklar.
Save (Form1)Dosya İsmi As: Daha önce saklanmış olan bir dosya yeni bir isimle yeniden saklanabilir.
Print:Project ile ilgili istenilen (kod sayfasını,formu) bölümleri yazıcıya gönderir.
Print Setup:Uygulamanızı yazıcıya aktarma durumunda yazıcı tipini, yazıcıdaki kagıt baskısını,yatay,dikey durumunun ayarı.
Make Project..exe:Çalıştığımız Visual Basic uygulamasını EXE haline çevirerek Visual BASIC ortamından bağımsız çalışılmasını sağlar.
Make Project Group:Uygulamamız birden fazla project içeriyorsa görüntülenir. Uygulamanızda oluşturmak istediğiniz projeleri seçmenizi sağlar.
Exıt:Visual BASIC ortamından çıkışı sağlar.

EDİT MENÜSÜ

Undo Delete(Gerial):Yapılan son işlemi geri alır.
Can’t Redo(Yinele): Geri alınan işlemi tersine çevirir.
Cut(Kes): Seçilen alanı silip panoya alır.
Copy(Kopyala): Seçilen alanı panoya kopyalar.
Paste(Yapıştır):Panodaki bilgileri yazdırır.
Paste Link(Özel Yapıştır):Panodaki bilgileri istenilen biçimde yapıştırır.
Delete: Seçilmiş metin yada nesneyi siler.
Select All: Aktif kod penceresindeki bütün kodu veya form üzerindeki bütün kontrolleri seçmek için kullanılır.
Find(Ara): Visual BASIC kodu içerisinde bir metni aramak için kullanılır.
Find Next(Aramaya Devam): Find ile yapılan arama işlemine kaldığı yerden devam etmek için kullanılır.
Replace(Değiştir): Bir metin içinde bir sözcüğü aratıp, bulunduğu takdirde başka sözcükle değitirmek.
Indent(Tab):Tab tuşunun görevini yapar.
Outdent(Shift Tab): Tab tuşunun ilerlettiği sutun miktarı kadar sola kaydırır.
Insert File(Dosya Birleştir): Çalışılan kod sayfasının içerisine başka bir dosyada bulunan kodu eklemek için kullanılır.
List properties/Methods: Kod penceresine her uygun ifadenin ardından bu ifadeden sonra yazılabilecek mümkün diğer ifadeleri içeren bir yardım kutucuğu görüntüler.(data1. sonra gelecek menü)
List Constants:Kod penceresinde,yazılan ifadenin alabileceği sabit değerleri içeren yardımcı bir pencere görüntüler.
Quick Info: Kod penceresinde seçilen fonksiyonların,metodların,prosedürlerin ve değişkenlerin yazılımını gösteren yardımcı bir pencere görüntüler..
Parameter Info: Kod penceresinde yazılan veya ifadelerin ,çerdikleri parametreleri gösteren yardımcı bir pencere görüntüler.
Complate Word: VB, yazmakta olduğunuz ifadeden kelimeyi bulmaya çalışır. Ve kullanmanızı sağlar.
Go to Row: Satıra git (Birinci,Önceki,Sonraki,Yeni)
Bookmark:Program kodunun çok sık kullanıldığı satırlarına kolay bir şekilde ulaşmak için kullanılır.

VİEW MENÜSÜ

Code: O esnada seçilmiş olan form ya da modülün Code Penceresini(prg. Yazıldığı pencere)görüntülemek amacı ile kullanılır.
ObJect: Aktif kod ile ilişkili olan nesneyi(form gibi)görüntülemek için kullanılır.
Definition: Form yada modülün Code Penceresinde kürsörün bulunduğu aktif prosedüre ait kod penceresini görüntüler.(Recordset,Data1)
Last Position: Kod penceresinde en son noktaya yeniden sıçrama yapmak istediğinizde kullanılır.
Object Browser: Bu seçenek ile Object Browser(Nesne Gözatıcısı)penceresi ekrana gelir.
Immediate Window: Bu menü alternatifi ile Immediate (hata ayıklama penceresi) ekrana gelecektir.
Locals Window: O esnada aktif prosedürde ki bütün değişkenleri ve değerlerini gösterir.
Watch Window: B-Break Modda, daha aönceden gözlem amacı ile tanımlanmış değişken ya da ifadenin o andaki değerini görüntülemek için kullanılır.
Calc Stack: Projeniz içinde, o esnada aktif olan prosedür çağrılarının listesini gönderir.
Project Explorer:Project (proje) başlıklı pencereyi ekrana getirir.
Properties Window: Properties(Özellikler) başlıklı pencereyi ekrana getirir. Bu pencerede o esnada aktif olan nesne için geçerli olan özelliklerin bir listesini ve bu özelliklere o esnada atanmış olan değerleri incelemek mümkümdür.
Form Layout Window:Daha öncede söylendiği gibi Layout penceresinde Formların ekrandaki pozisyonları mouse yardımı ile ayarlanabilir.
Property Pages: Tasarım ortamında kullanıcı tarafından oluşturulmuş bir kontrolün özelliklerinde değişiklik yapmak amacı ile özellik sayfalarını listeler.
Table
Zoom
Show Panes
Toolbox:Araç kutusunu görünür hale getirir.
Color Palette:Seçilmiş Visual BASIC nesnelerinin renklerini değiştirmek üzere, renk paletini ekrana getirir.
Toolbar:Visual BASIC kullandığı araç çubuğu gruplarından biri ekranda görüntülenebilir veya silinebilir.

PROJECT MENÜSÜ

Add Form:Aktif projenin içine yeni veya mevcut bir form katmak için kullanılır. (Form1 varken Form 2 ye geçilebilir.)
Add MDI Form: Bu menü alternatifi ile bir Multiple Document Interface (çoksayıda Doküman İçeren Arayüz) oluşturulabilir veye mevcut bir MDI formu uygulamaya ekleyebilirsiniz.
Add Module: Visual Basic/in bir forma ya da nesneye bağlı olmayan ve uygulamanın tüm bileşenleri tarafından kullanılabilen kodların modul adı verilmektedir.
Add Class Module: Bu menü alternatifi ile Sınıf Modülü (Class Module) denilen özel tipte bir modül oluşturmak mümkün olmaktadır. Sınıf modülünde, projenin tüm bileşenleri tarafından kullanılabilecek bir sınıf ile ilişkili tanımlar bulunabilir.
Add User Control: Sadece kendi projenizde kullanabileceğiniz ActiveX kont- rolleri oluşturmak için kullanılır. Active X kontrollerini başka tasarım ortam-larında da kullanmak için projenizi ActiveXConrol olarak başlatmanız gerekir.
Add Property Page: Oluşturduğunuz ActıveX kontrolleri için Özellik sayfası isimlendireceğimiz Property Page/ler oluşturmak için kullanılır.
Add User Document: Bu menu komutu Standart EXE modülü dışındaki proje modülleri ile beraber kullanılır. Projeye yeni yeni bir ActiveX dökümanı eklemek için kullanılır.
Add File: Daha önceden hazırlanmış genel maksatlı modüller, formlar, sınıf modülleri ve kaynak dosyalar gibi bileşenleri, o esnada aktif olan projenizin içine katma imkanı sağlar.
Remove (Dosya Adı)Form..(1,2,3) : Aktif projenizin içindeki bir dosyayı bu proje içinden çıkarma imkanı sağlar. Çıkarılan dosya disketten silinmez.
References: Projenizin içerisine başka uygulama programları ya da nesne kütüphanelerinden nesneler katma imkanı sağlar.
Components: Visual BASIC’te kullanabileceğimiz kontrol nesnelerinin sayı ve çeşidini arttırmak ve DLL uzantılı tasarımları projeye eklemek amacı ile kullanılır.
Project1 Properties: Visual BASIC projesi ile ilgili düzenlemeler yapmak için kullanılır. Diyalog penceresinin BAŞLIK ÇUBUĞU, Project Explorer penceresinde seçili aktif projenin ismini gösterir.

FORMAT MENÜSÜ

Aling:Form üzerinde seçilmiş nesnelerin pozisyonları,enson seçilen nes-neyi referans alacak şekilde aşağıdaki alternatifler bazalınarak hizalan-dırılır.
Left sol,Centers ortala,Tops Üst köşe,Middles üst alt orta noktaları eşit, Buttoms Alt köşe,To Grid en yakın Grid üst köşe noktası
Make Same Size: Bu menü alternatifi ile seçilen nesnelerin boyutlarında ayarlama yapılır.
Width Genişlik,Height Yükseklik,Both seçilen nesnelerin boyutları referans alınan nesne ile aynı yapılır
Size To Grid Seçilen nesneleri otomatik olarak formun en yakın grid noktalarına yerleştirir.
Horizontal Spacing Seçilen nesnelerin kendi aralarındaki yatay boşluklar istenilen alternatiflere göre ayarlanır.
Make equal:Seçilen nesnelerin kendi aralarındaki yatay boşlukları eşit hale getirir.
Increase:Seçilen nesnelerin kendi aralarındaki yatay boşluğu, kabul edilen bir grid hücresinin eni kadar artırır.
Decrease:Seçilen nesnelerin kendi aralarındaki yatay boşluğu kabul edilen bir grid hücresinin eni kadar azaltır.
Remove:Seçilen hücrelerin kendi aralarındaki yatay boşlukları kaldırır.
Vertical Spacing: Yukarıdaki menü seçeneğine eşdeğer bir fonksiyonu vardır. Sadece boşluk ayarlamaları düşey noktada yapılır.
Center in Form:Seçilmiş nesne grubu, bu grubun içindeki en dış nesnelere göre form üzerinde ortalanır.
Horizontaly: Seçilmiş nesne grubu içinde en sol dışdaki nesne ile en sağ dışdaki nesnenin, sırası ile üst ve alt köşe noktalarına göre tüm seçilmiş nesneleri yatay olarak ortalar.
Verticaly: Seçilmiş nesne grubu içinde en üst dışdaki nesne ile en alt dıştaki nesnenin,sırası ile üst ve alt köşe noktalarına göre bir ayarlama yapılır.
Order:Order menu seçeneği ikiye ayrılır.
Bring to Front:Seçilmiş olan nesneyi, formda mevcut diğer nesnelerin önüne getirir.
Send to Back: Seçilmiş olan nesneyi, diğer nesnelerin arkasına yerleştirir.
Lock Controls:Form üzerindeki kontrolleri, bulundukları pozisyonda kilitler.Öyle ki, kontroller bu komuttan sonra form üzerinde hareket ettirilemez.

DEBUG MENÜSÜ

Step Into:Tasarım esnasında Visual BASIC kodundaki o esnada kürsörün İşaret etmiş olduğu komutu çalıştırır.
Step Over: Step info komutuna benzer. Farkı, icra edilen aktif komutu, bir prosedür çağırma komutu ise, o prosedür tek bir komut gibi bütünü ile icra edildikten sonra, esas koddaki bir sonraki deyime geçilir.
Step Out: O esnada icra edilen fonksiyonun içinde kürsörün işaret etmiş olduğu komuttan itibaren bütün komutlar çalıştırılır ve fonksiyonun çağrıldığr esas kodda bir sonraki deyime geçilir.
Run To Cusor: Gene sadece tasarım anında kullanılabilecek bir komuttur. Programın icrası durmuş iken(Break Mode) icrayı yeniden başlatarak bir sonraki durma noktasının hangi komut olacağını belirler.
Add Watch:Bir değişken yada ifadenin programın icrası esnasında hangi değerleri aldığını izlemek üzere bir gözlemci mekanizma kurar.
Edit Watch: Gözlemci tanımı ile ilişkili değişiklik ya da düzeltme yapmak gerektiğinde kullanılır.
Quick Watch:Brake modda üzerinde durduğu değişkenin, özelliğin veya başka bir ifadenin değerini gösteren bir diyalog penceresi görüntüler.
Toggle Breakpoint:Tasarım esnasında kullanılabilen bir komuttur. Kod üzerinde ki durma noktalarını belirlemek için kullanılır.
Clear All Breakpoints:Toggle breakpoint komutu ile yerleştirilmiş olan bütün durma noktalarını iptal eder.
Set Next Statement:Sadece Break modunda kullanılabilir. Break moduna şu durumlarda erişilir.
Show Next Statement:Gene sadece break modda kullanılabilecek bir komuttur. İcra edilecek bir sonraki deyimi gösterilir.

TOOLS MENÜSÜ
Visual Data Manager: Bu menü alternatif, Visual BASIC içine, veri tabanlarının yönetimi konusunda çok yetenekli bir yazılım modülü olan
Visual Data Manager’ın eklenmesini sağlar.
Add-In Manager:Bağımsız yazılım modüllerinin Visual Basic ortamına katılmasını ya da bu ortamdan çıkarılmasını sağlar.

ADD-INS MENÜSÜ

Start:Geliştirdiğimiz projeyi icra etmek amacı ile kullanılır.F5 kullanılır.
Start With Full Compile:Start komutu ile Visual Basic sadece aktif kodu ve ilişkili kısımları derler. Belli bir anda projenizin tümünün derlenerek çalıştırılması istiyorsanız bu alternatifi seçmelisiniz.
Break:Normal akışını sürdüren programı durdurur ve programın çalışmasını breake modda sürdürülür.
End:İcra edilen programı durdurarak Visual BASIC’in kullandığı tüm sistem kaynaklarını iade eder.
Restart: İcrası durdurulmuş olan programın yeniden icra edilmesini sağlar.

Add Procedure:Kod penceresi içine bir prosedür yerleştirmek amacı ile kullanılır.
Procedure Attributes:Belirtilen herbir özellik veya metod için ayarlamalar yapabileceğiniz veya mevcut attribute’leri(nitelikleri) gözlemleyebileceğizi bir diyalog penceresi görüntüler.
Menu Editor:Geliştirdiğiniz uygulama içinde Visual BASIC ve Windowsun menülerine benzer şekilde menüler oluşturmak istediğinizde Menü Editörü size büyük kolaylık sağlayacaktır.
Options: Bu menü seçeneği kullanılırsa Visual BASIC ortamında çalışırken mevcut olan çeşitli sistem parametrelerini değiştirmek imkanı sağlayan diyalog penceresi karşınıza gelecektir.

WİNDOW MENÜSÜ
Split: Sadece kod penceresi(programın yazıldığı pencere)açık iken aktif olur. Kod penceresini yatay olarak ikiye ayırır.Eski hali için split seçilir.
Tile Horizontally:MDI modda,açık pencereleri yatay olacak şekilde eşit pencere boyutlarında ekrana yerleştirir.
Tile Vertically:Yukarıdaki menü seçeneği ile eşdeğerdir. Farklı olarak pencere ayarlamaları düşey olacak şekilde gerçekleştirilir.
Cascade:MDI modda, açık pencerelerin ekrandaki yerlerini üst üste cascade bir tarzda yeniden ayarlar.
Arrange Icons: MDI modda minimize edilmiş pencere ikonlarını anapencerenin alt sol köşesine göre yeniden düzenler.
WindowList: Bütün açık pencereleri listeler. Aktif yapılmak istenen pencere seçilirse ilgili pencere isminin sol yanında o esnada atif pencereyi gösteren işareti gözükecektir.

HELP MENÜSÜ

Visual BASIC konuları hakkında yardımcı bilgiler sunar.

I may seem to be arguing with myself in the two previous paragraphs, but this is merely friendly discussion. I propose that originality of the individual idea is not required as long as you think you can implement that idea better than those before you have.
So what I am saying is;
• Intermediate, beginner level programmers should come up with an original idea to be successful – people don’t want clones that aren’t as good as the real thing.
• Expert programmers can afford to release Slamm III and Slapshot 98, just a bit more advanced than last years version for a proven market.
What are ideas anyhow?
Well don’t worry this is not a metaphysical discussion – here is David’s definition of ideas;
“what you think you’re going to do – before you do it.”
Ideas form the blueprint for your game. These ideas may include plot or character sketches, action moves, diagrams of puzzles, interface concepts, dialog, even a specific programming technique to exploit.
How do I get them?
If you are anything like me, you will probably have way to many ideas, both for projects to do, and for aspects of those projects. But lets face it you are better off finishing 1 game than starting 30. (I really should learn from that)
Here’s a simple three step process to better abs… ideas, (too many American infomercials) you can repeat as many times as you require;
1. Stimulation (e.g. play other games, watch videos, movies, read books, music whatever)
2. Scribble (write down a bunch of stuff you are thinking of so you can remember it later)
3. Discuss ( brainstorm – with a group of people to refine your ideas and come up with new ones)
Just hope that the people you brainstorm with aren’t too critical of your lame ideas, even the most stupid suggestion may surprise you. Who would have thought a game with odd shaped falling blocks would take the world by storm (Tetris for those of you who don’t remember the 8-bit days).

The real world
With these wonderful ideas firmly in mind you go about implementing your program. You will probably find it’s just not possible to do it the way you had planned, or you come up with better ideas along the way.
This is probably a good thing, if you were able to achieve your ideas exactly you would have to be a master at planning. It is almost inevitable that as you develop your game you find your ideas were perhaps a bit ambitious or you think of a new idea or twist (within reason say the schedulers among us).
Now you have ideas, what makes a game?
For more on this topic see Greg Costikyan’s article “I have no words & I must design”
What’s not a game
• Puzzles – puzzles are static, not interactive. Good games probably have puzzle elements, but they should not be JUST a puzzle.
• Toys – toys are interactive, but have no goal. e.g. playing with blocks, sim-city.
• Stories – stories are linear, games are not. Any presentation of narrative should still allow for the user to make their own decisions.
What is a game
• Decision making – Interaction in itself does not make a game, the interaction must have outcomes. Hence the player makes a decision about what action to take which results in an outcome.
• Goals – There needs to be goals in a game so players can mark their progress – the quality of their decisions. E.g. points, survival, increased functions.
• Opposition – It is no fun playing with yourself. Remember it should be a struggle, it is also no fun to win too easily.
• Managing Resources – Part of the decision making progress is management of resources. E.g. should you use the extra ammo?, the health shield?, send those extra troops to the front?, spend the money on new tyres?.
• Information – A player needs information to make decisions. Information adds to the experience and realism of the game, also as a player becomes more experienced the information can be understood at greater levels of subtlety resulting in better tactics. E.g. use the wind meter when making the golf shot, listen for screams round the corner in an action game, read up background biographies in an adventure game.
What can make a better game
• Diplomacy – Multi-player games should encourage diplomacy (read social interaction). e.g. gang up on someone, go easy on a new member, perhaps help another group in an RPG although the long term goal may be different.
• Art – Not just graphic art, but the art of presentation. Anyone prefers a game with atmosphere that looks and sounds great – and plays easily (read good user interface).
• Simulation – This is taking real (or fictional) situations which people are familiar with and handing them the controls. This immediately gives you a basis of communication – famous characters or objects, the history and background, and the basic premise. E.g. fly a plane, control a city, command an army…
• Variety – Well this stands to reason, tic-tac-toe won’t keep people interested for long. You can provide variety in several ways, a) variety through random elements e.g. bonuses, good fortune, luck, b) through complexity of environment, c) progressive gameplay, e.g. the game changes as you progress
• Role-playing – Role playing is not simply presenting the player with a persona to assume e.g. batman, duke nukem, but putting the player in a social environment were they play a role in respect to their interactions with other players. E.g. the player is Barry the barbarian or Tracy the ruthless tycoon.
• Socializing – It is an interesting aspect that most computer games have been a solitary pass time, yet other forms of games are almost all social in nature, e.g. sport, cards, board games… The Internet is now making multiplayer gaming a technical possibility, but I would suggest they will really take off when the social aspect is exploited. I don’t know about you, but after my first game of Net Doom with my friends, the big difference I noticed was not the improvement over computer AI (infact charging the enemy.. or walls with rocket launchers seemed very popular) but the social aspect (never yelled over a computer game before).
• Tension – Just like at the movies, the key element of an exciting story is to keep the tension rising until reaching the dramatic ending. Try and save the toughest problems for last, e.g. beat the end of level bad guy, disarm the bomb, save the world.
Basic game categories
Games generally fall into basic categories. You should keep these in mind as far as implementing your game, but you may choose to mix and match parts of each genre.
• Platform Games – Run, Jump and Avoid e.g. Mario, Jazz Jackrabbit, Prince of Persia. Can be non-violent and non-threatening.
• Shooting – If it moves shoot it, you know doom, quake…
• Adventure – Multiple locations, objects, characters and actions aimed at a goal in a specific carefully defined world. Kings Quest, Sam and Max…
• RPG – Multiple locations, objects, characters and actions in a more free form exploration of a usually larger less defined world. Ultima..
• Strategy – Combination of planning, analysis resource management or logic. Chess, Tetris, Civilization, Command and Conquer..
• Fighting – Spinning back kick to the jaw, Mortal Kombat, Street Fighter…
• Simulation – General term to describe “real world games”, flying, driving, sports..
Two basic implementation techniques
You can generally divide the graphics of games programming into two distinct areas (although a game may combine aspects of both.)
• 2D – Sprites, scrolling, bitmaps, video and animation – FLAT
• 3D – Free viewpoint, textured polygons – NOT FLAT
That may seem simplistic, but basically 2D and 3D graphics are very different techniques.
We will cover the basics of 2D graphics later on. Its basically a fairly straightforward concept – images (like paper cut-outs) are located where you want on the screen…
3D games meanwhile involve a lot more work (and maths!). Luckily (?) there are all sorts of people trying to develop 3D API’s for you to use.
I will be including some samples of Microsoft’s Direct3D Retained Mode interface (the easy one) and have a look at OpenGL (despite Microsoft’s claims, a competing API). Thanks to Patrice Scribe for the wonderful type libraries that make this possible.
Implementing your ideas
Where do you start?
Technique
You need to establish early on (read start) of your project what techniques you will use – and you need to make sure you can do it.
The techniques required may be obvious from your ideas, or they may still be undefined. E.g. will your adventure game be first person like Myst (scale and character not required), will characters be able to walk around like in Sam and Max, or will you have a little 2D square playing field like Indiana Jones’s desktop adventures?
Now you need to research and test until you have a mock up of the technique sufficient to satisfy you that you can do the whole project. There is no point starting on a quake clone, 6 months into the project with music, textures and 3D models – but no hope of a 3D engine.
Research is not as bad as it sounds, there are tonnes of books, articles, web sites and source code to point you in the right direction. I will even include a modest sample of 2D stuff later on including three worked examples. You never know you may have some new ideas everyone else might want to hear.

Brief
Its time to do a rough plan. Before you commit all you spare time for months to a project, sketch out a storyboard for your game, illustrating it cool points – and its basic premise.
Draw up a list or resources required Personnel (you may need artists, music gurus, programmers, writers…), time (you know that stuff that there is NEVER enough of – unless you’re at the dentist), and equipment (computers, software, video, midi keyboards..)

Reality Check
Right – you have got your technique tested, you have a concise brief describing your game – now check the following.
1. Possible – just make sure (again) you genuinely think you can pull off the technical bits
2. Practical – is the scope of the project within your grasp, remember the best game is a finished game
3. Property – do you have the money and resources (or the right contacts). Remember video equipment, artists, ILM special effects and Arnold Schwarzenegger don’t come cheap.
4. Potential – what do your friends (publisher, co-worker..) think of your game, would they want to play what you are describing?
This stage can save a lot of disappointment and lost work. Should you fail the reality check its time to rework your brief.
How do you start?
Break your game into components
Basic categories of “components” that you will need for your planning include;
• Game engine
• Extra programming (installation, extra puzzles..)
• User Interface design
• Assets (Models, Art, Sound Effects, Music, Video)
• Content editor and utilities (e.g. level editor and sound conversion..)
• Content designs (e.g. level’s)
Plan, Plan and Plan some more
If your game is a large project, especially if your team is larger than one person, you owe it to yourselves to get organised. Get some idea on a timeline of who does what when. E.g. tell your artist roughly what art, when, what size, resolution and colour depth.. etc
Evaluate Key techniques in detail
Well you have made sure you can blit a screen full of diamond tiles fast enough, now its time to add buildings and trees and get the whole thing scrolling.
Early on in the implementation phase you need to break the back of the main technical issues, these will make planning difficult. If you don’t know how to do it, how can you estimate how long it will take?
If its not working fast enough, or just not working then you need to;
1. do some more research,
2. buy some technology, or
3. scale down your game.
Huh?
If at this point you are wondering what you missed (where are all the explanations of how to MAKE A GAME? ) well that’s still pretty much up to you, programming is fairly creative and there are lots of different styles and techniques.
Don’t worry though, here are some links to some good places to start, and I have even included some basic techniques along with some worked examples.
Following through
Working in teams
Milestones
Tie up the loose ends
Some programming techniques for you to use
Classes & collections
Relatively new to VB is the ability to take advantage of classes, your own little object templates. MS has also been considerate enough to provide collections, the ability to dynamically manage a group of objects.
Very quick OOP tutorial
A class is a template from which you can create objects.
Each object has its own data space for its properties, and shares the methods and event code with other objects of the same class.
Think state housing, you can take the blueprint of a state house and build 30 different identical buildings. You can then go through and alter the properties of the individual objects (houses) and paint each one a different, disgusting pastel shade.

The VB manual even describes classes and “user-defined types with attitude” because you can store the events and methods along with the data (encapsulation).
So why bother?
Well collections make all this new-age OOP stuff worthwhile. They provide a simple way to dynamically manage objects. Collections also provide indexing so you can find specific objects quickly in large collections.
Because objects can contain collections of other objects you can create structures that you would have needed pointers (urgh) for before.

For example in a RPG;
Player Class contains properties like name, age, gender, height, experience, speed, agility, strength, stamina… and a collection called holding
This collection contains a group of other objects like clothes, knife, backpack. Each of these objects has their own properties. The backpack for example contains properties like size, colour AND a collection called holding. This collection can in turn “hold” other objects!
Even better VB5 provides a class wizard that makes it easy to create and maintain the interfaces to your classes.
Some Source Code!
Here’s some fragments of code you will want to get familiar with;
• Dim my_axe as Axe (dimension a variable of type Axe)
• Set my_axe as new Axe (set the variable to a new instance of a Axe class, a new object)
This means you now have a working and ready to use object, my_axe which is explicitly of type Axe (your class). If you want to be really flexible you can define my_axe as Object. This means you can set my_axe to any new object.
• Dim my_axe as Object (dimension a variable of type any object)
• Set my_axe as new Whatever (set the variable to a new instance of any object)
However this uses late binding, because it does not know what object will be used until you do the set statement. This is slightly slower, so if you can help it try and be explicit as above.
p.s. now you have an object you can use it just like other vb objects, e.g. text1.text=”test” or my_axe.sharpness=400.
What about collections? Right, good point.
• Dim holding As New Collection
I now have a variable called holding which is a collection which can contain a group of any sort of objects.
• holding.Add my_axe, “axe” (adds a new objects, my_axe, and an optional text index “axe”)
• holding.count (tells you how many objects in the collection)
• holding.remove “axe” (removes the object from the collection which has a text index “axe”, you could equally remove the item in ordinal position, e.g. holding.remove 2 removes the 2nd item in the collection.)

p.s. before you could add the item my_axe, you have to dimension a variable my_axe as axe, and set my_axe = new axe – then set any properties you want for that specific axe before you add it to the collection.
That’s how to add, count and remove items in a collection. But I have saved the best till last – the for each construct.
• For Each player In players
• Next
Where players is a collection of objects of class player. You can now write code that will work on each object in a collection.
• For Each player In players
o If player.speed < 50 Then
 player.die
o End If
• Next
BitBlt
The taxonomy of a bitblt. Lets just say that bltblt’s are still faster than the new VB paintpicture method. Essentially what you are doing is copying a chunk of memory from one place to another. This chunk is visually rectangular in shape.
Declare Function BitBlt Lib “gdi32″ (ByVal hDestDC As Long, ByVal X As Long, ByVal Y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal dwRop As Long) As Long
Public Const SRCAND = &H8800C6 ‘ (DWORD) dest = source AND dest
Public Const SRCCOPY = &HCC0020 ‘ (DWORD) dest = source
Public Const SRCINVERT = &H660046 ‘ (DWORD) dest = source XOR dest
Declare Function sndPlaySound Lib “winmm.dll” Alias “sndPlaySoundA” (ByVal lpszSoundName As String, ByVal uFlags As Long) As Long
Add these declares to a BAS module in you project. (I added the sndPlaySound function cause it’s a really easy way of playing wave files, just tmp&=sndPlaySound(“mywave.wav”,1))
Right, what does the different parameters of the bitblt do?
• HDestDC this is the destination HDC (handle to a Device Context) read – form or picture box
• X,Y is the position the destination rectangle will start at
• NWidth, nHeight is the width and height of the rectangle
• HSrcDC is the source HDC – read form or picturebox
• XSrc, ySrc provide the offset, or position the source rectangle starts at
• DwRop is the Raster Operation – read what boolean operation to apply
The key to using bitblt easily is that pictureboxes make great sources for BitBlting. If you make a picturebox autoredraw=true and visible=false then load a picture into the picturebox, it will create an offscreen buffer for you to blt from.
e.g. tmp& = bitblt(form1.hdc,10,10,20,20,picture1.hdc,0,0,srccopy)
Now, form1 is the destination for the bitblt, (where you want the picture to appear). 10,10 is the pixel offset into form1 while the rectangle will be 20 pixels square. Picture1 (invisible and autoredraw=true) is the source image, the chunk taken from 0,0 and srccopy the operation. (srccopy just copies the data)
Sprites
Whats a sprite
Well now that you know a bit about bitblting, lets find out how to blt sprites. Sprites are little irregular images, i.e. NON rectangular.
To make these irregular shaped images we need some trickery, now while you may eventually, or already have, custom routines to blt sprites rotated, sheared, transparent and lit – I am going to focus on using bitblt.
The technique I will show is called masking. The idea is that an image has an associated mask. This mask is applied first, leaving a hole for the image. This is achieved through ROP’s or raster operations. This is boolean logic on a large scale.
Masks are designed white, with black where they should leave a “hole”. To apply the mask to the destination image, rather than just copying the image, we need to SCRAND the mask with the image. This means to make a logical AND of each pixel. The result is that the destination pixel AND’ed with white is the destination pixel, while the destination pixel AND’ed with black is black (the “hole”).
The image can then be applied. The image should be designed to be black where the mask was white, and coloured where the mask was black. Once again a straight copy is not appropriate as this would not be irregularly shaped. We use SCRINVERT, this is a logical XOR. The result of this is that the destination XOR’ed with the black surroundings is the destination, and equally the black destination pixels from our mask, XOR’ed with the coloured centre of the sprite result in the coloured centre of the sprite.
Here’s a diagram,

Check out the example programs later on for some source code. (whackarat)
Double Buffering
Well the problem with masking, and games in general is that things move around all the time, if computers were infinitely fast this would not be a problem – but as we well know, they bloody well are not. Hence to stop a nasty looking kind of partial redrawing, half done, flickery kind of look, adding buffering to your games is a good plan.
This can be easily described – draw it offscreen, then when you have done all the messy stuff, copy the whole lot to screen.

To see some samples of this in use, check out the examples later on. (whackarat)
DirectDraw
Well MS have come to the “rescue” of beleaguered game developers, providing a standard hardware independent API for fast gaming. However despite its critics, it has made Windows95 gaming a reality. Whats more all that masking and double buffering stuff above is BUILT IN!
Now thanks to Patrice Scribe VB programmers can use DirectX too. I am just going to stick to DirectDraw (the basics) for now. I would recommend downloading the MS SDK to find out more.
Remember you need Patrice Scribes type libraries.—
Steps
• Choose windowed, or a specific full screen mode (e.g. 640 x 480, 16 bit colour)
• Dimension a directdraw object
• Make some DirectDraw surfaces
• Load bitmaps into some surfaces (apply a transparent colour key if required)
• Do your bitblting in a game loop until game finishes
• Set objects to nothing
• Restore the screen
Sounds easy?, well I hope so, cause that’s a real simple overview of the main steps. Luckily, you can just use code from someone else, you don’t really need to know the details of what each bit does.
Hence heres a simple framework to download don’t forget to check out the menace sample code.
Here is the code and descriptions of what It does.
Boring Declares, you need to add your variables, and any surfaces for bitmaps you want to add.
Dim u As Long
Dim blnend As Boolean
‘ Win32
Const IMAGE_BITMAP = 0
Const LR_LOADFROMFILE = &H10
Const LR_CREATEDIBSECTION = &H2000
Const SRCCOPY = &HCC0020
Private Type BITMAP
bmType As Long
bmWidth As Long
bmHeight As Long
bmWidthBytes As Long
bmPlanes As Integer
bmBitsPixel As Integer
bmBits As Long
End Type
‘ GDI32
Private Declare Function GetPixel Lib “gdi32″ (ByVal hdc As Long, ByVal x As Long, ByVal y As Long) As Long
Private Declare Function CreateCompatibleDC Lib “gdi32″ (ByVal hdc As Long) As Long
Private Declare Function DeleteDC Lib “gdi32″ (ByVal hdc As Long) As Long
Private Declare Function DeleteObject Lib “gdi32″ (ByVal hObject As Long) As Long
Private Declare Function GetObject Lib “gdi32″ Alias “GetObjectA” (ByVal hObject As Long, ByVal nCount As Long, lpObject As Any) As Long
Private Declare Function SelectObject Lib “gdi32″ (ByVal hdc As Long, ByVal hObject As Long) As Long
‘ USER32
Private Declare Function GetDC Lib “user32″ (ByVal hwnd As Long) As Long
Private Declare Function LoadImage Lib “user32″ Alias “LoadImageA” (ByVal hInst As Long, ByVal lpsz As String, ByVal un1 As Long, ByVal n1 As Long, ByVal n2 As Long, ByVal un2 As Long) As Long
Private Declare Function StretchBlt Lib “gdi32″ (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal nWidth As Long, ByVal nHeight As Long, ByVal hSrcDC As Long, ByVal xSrc As Long, ByVal ySrc As Long, ByVal nSrcWidth As Long, ByVal nSrcHeight As Long, ByVal dwRop As Long) As Long
Private Declare Function ShowCursor Lib “user32″ (ByVal bShow As Long) As Long
Const ResolutionX = 640 ‘ Width for the display mode
Const ResolutionY = 480 ‘ Height for the display mode
Dim dd As DirectDraw2 ‘ DirectDraw object
Dim ddsdFront As DDSURFACEDESC ‘ Front surface description
Dim ddsFront As DirectDrawSurface2 ‘ Front buffer
Dim ddsBack As DirectDrawSurface2 ‘ Back buffer
Dim ddCaps As DDSCAPS ‘ Capabilities for search
Dim fx As DDBLTFX
‘******************************
‘your own surfaces here , e.g.
Dim aDDS As DirectDrawSurface2 ‘ Images to blit
Dim tDDS As DirectDrawSurface2 ‘ tiles to blit
‘ Loads a bitmap in a DirectDraw surface
Private Function CreateDDSFromBitmap(dd As DirectDraw2, ByVal strFile As String) As DirectDrawSurface2
Dim hbm As Long ‘ Handle on bitmap
Dim bm As BITMAP ‘ Bitmap header
Dim ddsd As DDSURFACEDESC ‘ Surface description
Dim dds As DirectDrawSurface2 ‘ Created surface
Dim hdcImage As Long ‘ Handle on image
Dim mhdc As Long ‘ Handle on surface context
Dim clr As Long ‘hold the colour top left to be made transparent
‘ Load bitmap
hbm = LoadImage(ByVal 0&, strFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE Or LR_CREATEDIBSECTION)
‘ Get bitmap info
GetObject hbm, Len(bm), bm
‘ Fill surface description
With ddsd
.dwSize = Len(ddsd)
.dwFlags = DDSD_CAPS Or DDSD_HEIGHT Or DDSD_WIDTH
.DDSCAPS.dwCaps = DDSCAPS_OFFSCREENPLAIN
.dwWidth = bm.bmWidth
.dwHeight = bm.bmHeight
End With
‘ Create surface
dd.CreateSurface ddsd, dds, Nothing
‘ Create memory device
hdcImage = CreateCompatibleDC(ByVal 0&)
‘ Select the bitmap in this memory device
SelectObject hdcImage, hbm
‘ Restore the surface
dds.Restore
‘ Get the surface’s DC
dds.GetDC mhdc
‘ Copy from the memory device to the DirectDrawSurface
StretchBlt mhdc, 0, 0, ddsd.dwWidth, ddsd.dwHeight, hdcImage, 0, 0, bm.bmWidth, bm.bmHeight, SRCCOPY
‘get the top left colour
clr = GetPixel(mhdc, 0, 0)
‘ Release the surface’s DC
dds.ReleaseDC mhdc
‘ Release the memory device and the bitmap
DeleteDC hdcImage
DeleteObject hbm
‘make surface transparent
Dim mhddck As DDCOLORKEY
mhddck.dwColorSpaceLowValue = clr ‘really works only for 24 bit colour
mhddck.dwColorSpaceHighValue = clr ‘but as sprites have black is all 0 at any rate
dds.SetColorKey DDCKEY_SRCBLT, mhddck
‘ Returns the new surface
Set CreateDDSFromBitmap = dds
End Function
Private Sub Form_KeyPress(KeyAscii As Integer)
‘quit out for now
blnend = True
End Sub
Add you own images to be loaded in here, and any data you may want to load like maps…
Private Sub Form_Load()
ShowCursor 0
‘ Create the DirectDraw object
DirectDrawCreate ByVal 0&, dd, Nothing
‘ This app is full screen and will change the display mode
dd.SetCooperativeLevel Me.hwnd, DDSCL_EXCLUSIVE Or DDSCL_FULLSCREEN
‘ Set the display mode (16 is the bit depth)
dd.SetDisplayMode ResolutionX, ResolutionY, 16, 0, 0
‘ *****************************
‘ Load your own images, e.g.
Set aDDS = CreateDDSFromBitmap(dd, App.Path & “\menace.BMP”)
Set tDDS = CreateDDSFromBitmap(dd, App.Path & “\tiles.BMP”)
‘ Fill front buffer description structure…
With ddsdFront
‘ Structure size
.dwSize = Len(ddsdFront)
‘ Use DDSD_CAPS and BackBufferCount
.dwFlags = DDSD_CAPS Or DDSD_BACKBUFFERCOUNT
‘ Primary, flipable surface
.DDSCAPS.dwCaps = DDSCAPS_PRIMARYSURFACE Or DDSCAPS_FLIP Or DDSCAPS_COMPLEX Or DDSCAPS_SYSTEMMEMORY
‘ One back buffer (you can try 2)
.dwBackBufferCount = 1
End With
‘ Create front buffer
dd.CreateSurface ddsdFront, ddsFront, Nothing
‘ Retrieve the back buffer object
ddCaps.dwCaps = DDSCAPS_BACKBUFFER
ddsFront.GetAttachedSurface ddCaps, ddsBack
End Sub
Heres where everything happens, insert your game here! The drawnextframe subroutine is called in a tight loop – updating as fast as possible.
I have put a stupid example in here for you, painting the backbuffer black, and copying a bit of bitmap to the same place every frame.
Useless I know, but I included the clearbackbuffer, as it may come in handy for asteroids type games where you want to start with a new black screen every frame.
The sample bltfast routine is just to show you how it works. You basically use the RECT to describe where from your surface you want to pull the graphics from. You then reference ddsBack (the back buffer you draw on, and we later flip to the front) method bltfast with the x and y position for the sprite, your sprite surface, the aforementioned RECT and some constants.
p.s. If you want your blit to be a solid rectangle rather than irregular use DDBLTFAST_NOCOLORKEY instead of DDBLTFAST_SRCCOLORKEY
Private Sub DrawNextFrame()
‘you may wish to clear the beackground first e.g.
ClearBackBuffer
‘do your bltting in here. This is where all the good
‘stuff goes e.g. a simple example
Dim t As RECT
t.Top = 10
t.Left = 10
t.Right = 100
t.bottom = 100
ddsBack.BltFast xx%, yy%, tDDS, t, DDBLTFAST_SRCCOLORKEY Or DDBLTFAST_WAIT
‘beware BltFast relies on you making sure
‘the rectangle is not bigger than the
‘screen.
‘flip the buffers
Do
ddsFront.Flip Nothing, 0
If Err.Number = DDERR_SURFACELOST Then ddsFront.Restore
Loop Until Err.Number = 0
End Sub
Sub ClearBackBuffer()
Dim t As RECT
‘On Error Resume Next
‘ Clear the back buffer
With fx
.dwSize = Len(fx)
.dwFillColor = RGB(0, 0, 0)
End With
t.Top = 0
t.Left = 0
t.bottom = ResolutionY
t.Right = ResolutionX
ddsBack.Blt t, Nothing, t, DDBLT_COLORFILL, fx
End Sub
Here’s the main tight loop, followed by the clean up stuff…
Private Sub Timer1_Timer()
Timer1.Enabled = 0
‘Render loop
While Not blnend
DrawNextFrame
u = DoEvents
Wend
‘clean up
Set aDDS = Nothing
Set tDDS = Nothing
dd.FlipToGDISurface
dd.RestoreDisplayMode
dd.SetCooperativeLevel 0, DDSCL_NORMAL
Set ddsBack = Nothing
Set ddsFront = Nothing
Set dd = Nothing
ShowCursor 1
Unload Form2

End Sub

Örnek 1.2.1 : 1′den 100′e kadar olan sayıların toplamını veren algoritma.
1. Toplam T, sayılar da i diye çağırılsın.
2. Başlangıçta T’nin değeri 0 ve i’nin değeri 1 olsun.
3. i’nin değerini T’ye ekle.
4. i’nin değerini 1 arttır.
5. Eğer i’nin değeri 100′den büyük değil ise 3. adıma git.
6. T’nin değerini yaz.
Algoritmaların yazım dili değişik olabilir. Günlük konuşma diline yakın bir dil olabileceği gibi simgelere dayalı da olabilir. Akış şeması eskiden beri kullanıla gelen bir yapıdır. Algoritmayı yazarken farklı anlamlar taşıyan değişik şekildeki kutulardan yararlanılır. Yine aynı amaç için kullanılan programlama diline yakın bir (sözde kod = pseudo code) dil , bu kendimize özgü de olabilir, kullanılabilir.

Aynı algoritmayı aşağıdaki gibi yazabiliriz.
1. T=0 ve i=0
2. i’nin değerini T’ye ekle.
3. i’yi 1 arttır.
4. i<101 ise 2.adıma git.
5. T'nin değerini yaz.

Algoritmayı bir de akış şeması ile gerçekleyelim.

T=0
İ=0

İ’nin Değrini T’ye ekle

İ’yi bir arttır

İ<101

T’yi yaz

Örnek 1.2.2 : ax2+bx+c=0 tipi bir denklemin köklerini veren algoritma.
Girdi : a, b ve c katsayıları Çıktı : denklemin kökleri
1. a, b ve c katsayılarını al.
2. D = b2-4ac değerini hesapla.
3. D<0 ise gerçel kök yok. 7. adıma git.
4.
5 .
6. değerlerini yaz.
7. Dur.
Döngü Gösterimi
Tekrarlanan adımlar
n Koşul sağlandığı sürece
n.1 ...
n.2 ... tekrarlanan adımlar
n.3 ...

Örnek 1.2.3 : İki tamsayının çarpma işlemini sadece toplama işlemi kullanarak gerçekleyin.
Girdi : iki tamsayı
Çıktı : sayıların çarpımı
1 a ve b sayılarını oku
2 c =0
3 b>0 olduğu sürece tekrarla
.3.1. c=c + a
3.2. b = b-1
4. c değerini yaz ve dur

Örnek 1.2.4 : Bir tamsayının faktoriyelini hesaplayınız.
Girdi : Bir tamsayı
Çıktı : sayının faktoriyel
İlgili formul: Faktoriyel(n)=1*2*…*n
1 n değerini oku
2 F=1
3 n >1 olduğu sürece tekrarla
.3.1. F=F*n
3.2. n= n-1
4 F değerini yaz
Örnek 1.2.5 : İki tamsayının bölme işlemini sadece çıkarma işlemi kullanarak gerçekleyin. Bölüm ve kalanın ne olduğu bulunacak.
1. a ve b değerlerini oku
2. m=0
3. a>=b olduğu sürece tekrarla
1 a=a-b
2 m = m + 1
4. kalan a ve bölüm m ‘yi yaz

Örnek 1.2.6 : 100 tane sayıyı okuyup, ortalamasını bul
1 T=0, i=0
2 i<101 olduğu sürece tekrarla
3 m değerini oku
4 T = T + m
5 i = i + 1
6 T = T / 100
7 Ortalama T ‘yi yaz
8 Dur

Örnek 1.2.7 : Bir sınava giren öğrencilerin not ortalamasının hesaplanması
1 Tüm sınav kağıtlarını inceleyip notların toplamını hesapla
2 Ortalamayı notların toplamını incelenen sınav kağıdına bölerek hesapla
3 Ortalamayı yaz.

1 Notların toplamını ve incelenen sınav kağıdı sayısını sıfır kabul et
2 Sıradaki sınav kağıdının notunu notların toplamına ekle
3 İncelenen sınav kağıdı sayısını Bir arttır
4 İncelenecek sınav kağıdı var ise 2. Adıma git
5 Ortalamayı notların toplamını incelenen sınav kağıdına bölerek hasapla
6 Ortalamayı yaz

1 Notların toplamını ve incelenen sınav kağıdı sayısını sıfır kabul et
2 Her bir sınav kağıdı için
3 Sıradaki sınav kağıdının notunu notların toplamına ekle
4 İncelenen sınav kağıdı sayısını bir arttır
5 Ortalamayı notların toplamını incelenen sınav kağıdına bölerek hesapla
6 Ortalamayı yaz

Koşul Gösterimi

n Koşul doğru ise
n.D.1
n.D.2 doğru olduğunda işlenen adımlar
n.D.3
aksi halde
n.Y.1
n.Y.2 yanlış olduğunda işlenen adımlar
n.Y.3

Kök bulma örneğinde 3. Adımı tekrar yazarsak
3 D>=0 ise
3.D.1
3.D.2
aksi halde
3.Y.1 Reel kök yoktur

Sorular:
* Girilen üç sayıdan en büyüğünü bulan algoritmayı yazınız.
* Tamsayılarda üs alma işlemini gerçekleştiren algoritmayı yazınız ( ab ).
* 1-100 arasında tutulan bir sayıyı tahmin eden algoritmayı yazınız.

Örnek 1.2.8 : Aracın otopark ücretinin hesaplanması. Araçların en fazla 24 saat kaldığını varsayın.
0 – 2 saat 150 bin
2 – 8 saat 300 bin
8-24 saat 500 bin

1 Aracın kaç saat kaldığını öğren ( t olsun ).
2 t <= 2 ise
2.D.1. ücret = 150 bin
Aksi halde
2.Y.1. t<=8 ise
2.Y.1.D.1. ücret = 300 bin
Aksi halde
2.Y.1.Y.1. ücret = 500 bin

3 ücreti yaz
4 Dur

Örnek 1.2.9: Sınavdaki en büyük notun bulan algoritma.

1 En büyük = ilk sınav kağıdındaki not (ya da olabilecek en düşük değer kabul edilebilir).
2 İncelenecek sınav kağıdı var ise
3 Sınav kağıdındaki not > En büyük ise En büyük = Sınav kağıdındaki not

3 En büyük değerini yaz.
4 Dur

Algoritmanın yazımı daha simgesel olabilir. Ni i. Öğrencinin notu olsun.

1 EB = N1
2 i = 2
3 İncelenecek sınav kağıdı var ise
4 Ni>EB => EB = Ni
5 i = i + 1

4 EB’ yi yaz.
5 Dur

Örnek 1.2.10 : Programın C dili ile yazılıp çalışır hale getirilmesi.

1 Programı bilgisayara gir
2 Kaynak dosya olarak kaydet
3 Kaynak dosyayı derle ( compile)
4 Derleme sonucunda hata var ise
5 Hataları düzelt
6 3. Adıma git
7 Oluşan amaç dosyasına diğer dosyaları bağla (link)
8 Bağlama sonucunda hata var ise
9 Hataları düzelt
10 Hatalar kaynak dosya ile ilgili ise 2. adıma aksi halde 5. adıma git
11 Program çalıştırılmaya hazır

2- Programlamaya Giriş

Program : Belirli bir problemi çözmek için bir bilgisayar dili kullanılarak yazılmış deyimler dizisi.
Önceki bölümde bir problemin çözümü ile ilgili teknikler sunmuştuk. Bir problemi bilgisayar ile çözmek için geliştireceğimiz programın yazımında izleyeceğimiz adımlar:

i) Problemin ne olduğunu kavra. Çözüm için gereksinimleri belirle.
ii) Problemin girdilerini, çıktılarını ve diğer kısıtlama ve gereksinimleri belirle ( bilgilerin giriş ve çıkış biçimlerinin nasıl olacağına kadar).
iii) Problemin çözümünü veren algoritmayı yaz.
iv) Algoritmayı bir programla dili ile yaz.
v) Programın doğru çalışıp çalışmadığını test et. Bu testi değişik veriler (girdiler) için tekrarla.

2.1 İlk Program Örneği
#include Kullanılan işlevler ile ilgili başlık dosyası
main()
{
int i ; Değişken tanımı
scanf(“%d”,&i); Programın gövdesi
i:=i*i;
printf(“%d”,i);
}

BCPL  B (1967 Ken Thompson)  C (Denis Ritchie unix i yazmak için)
az sayıda saklı sözcük kısa ve etkin program çok sayıda işleç assembler e yakın kod taşınabilir kod kullanıcıya bırakılan kontroller (dizinin boyutu gibi ) düşük okunabilirlik
source —–> compiler —–> object —–> link
kaynak derleyeci amaç bağlama
kaynak kod : C dili ile yazılmış olan program.
derleyeci : Kaynak kodu makina koduna çevirir
amaç kodu : Kaynak kodun makina dilindeki karşılığı
bağlama : Birden fazla amaç kodu dosyasının tek dosyada birleştirilmesi
2.2 Veri Tipleri

Veri tiplerini vermeden önce yazılan bir programın geçtiği aşamalara göz atalım.

2.2.1 Int Tip
Integer = Tamsayı
Tamsayıları içerir. Bellekte 2 Byte tutar.
5 , -19 , 25000 gibi
Minimum : -231 = -32768
Maksimum : 231-1 = 32767

2.2.2 Gerçel Tipler (Float, Double)
Gerçel sayıları içerirler.
float : Bellekte 4 Byte yer tutar. 3.4E-38 ile 3.4E+38 aralığında değer alır. Hassasiyet 7-8 basamaktır.
double : Bellekte 8 Byte ter tutar. 1.7E-308 ile 1.7E308 aralığında değer alır. Hassasiyet 15-16 basamaktır.

218.1 , -5.2 , 4.0

Bilimsel gösterim biçimi 2.5*103 = 2.5E3 2.5*10-3 = 2.5E-3

2.2.3 Char Tip
Char : Karakter : Alfanumerik karakterleri içerir.
’5′ , ‘*’ , ‘K’

2.3 Sabitler (CONST)

#include
main()
{
const float PI=3.14; Tanımlama kısmı
float r, Alan;
scanf(“%f”,r);
alan := PI*r*r;
printf((‘Alan = %f’, alan);
}
CONST (sabit) : Değeri programın çalışması boyunca değiştirilemez. Kullanım biçimi
const tip Belirleyici=değeri;
const float PI=3.14;
Tip belirtilmez ise tamsayı kabul edilir.

2.4 Değişkenler
Değeri programın çalışması boyunca değiştirilekir. Kullanım biçimi:
Tip Belirleyici [,Belirleyici] ;
int i;
float alan;

2.5 Belirleyiciler (Identifier)
Bileşenlere isim verme. (Sabit, değişken, altprogram, etiket, tipler (kullanıcı tanımlı)).

2.5.1 Kısıtlamalar
. İlk karakteri rakam olamaz
. Sadece harfler, rakamlar ve _ (underscore) karakterinin birleşiminden oluşabilir.
. C diline ait saklı (reserved) sözcükler kullanılamaz.
. En fazla 31 karakter olabilir.
. Küçük – büyük harf ayırımı vardır.

2.5.2 isimlerin Seçimi
. Belirleyicinin kullanım amacına uygun anlamlı isim seçin. (Hungarian notation)
. Ne fazla kısa ne de fazla uzun olsun. 3 – 10 karakter uzunluğunda olmasını alışkanlı edinin.
2.6 Matematiksel ifadeler
Matematiksel ifadeleri günlük hayattaki biçimde bilgisayarda yazamadığımız için belli bir kurallar uymamız gerekir. Kullandığımız matematiksel işlemler ve anlamları şöyledir:
+ , – , * , / toplama, çıkarma, çarpma, bölme
% tamsayı bölme sonucundaki kalanı verir (modulus)
7. / 2 —> 3.5 (nokta sayının gerçel yorumlanmasını sağlar)
7 / 2 —> 3 (sayılar int kabul edilip sonuçta int tipine dönüştürülür)
7 % 2 —> 1
2 % 7 —> 2
2 / 7 —> 0
Matematiksel ifadeler hesaplanırken izlenen adımlar:
1. Önce parantez içindeki ifadeler hesaplanır. İçiçe parantezler var ise hesaplamaya en içteki parantezden başlanır.
2. ilk önce * , / ve % işlemleri daha sonra + ve – işlemleri yapılır.
3 Öncelik sırası aynı olan işlemlerde hesaplama soldan sağa doğru yapılır. 5./2*3 –> 7.5

Bir C Programının Genel Yapısı

başlık dosyaları. Kullanılan deyimler ile ilgili
main()
{
sabitler ; sabitlerin tanımlama bölümü
değişkenler; değişkenleri tanımlama bölümü
deyimler; Program gövdesi
}

2.7 Atama Deyimi (Assignment)
Bir değişkene bir değer(sabit, değişken, ifade) vermek.
DeğişkenAdı = değer;
x = 8 ;
y = x + 15 ;
y = (8 – x) / (2 – x) ;

Örnek 2.7.1: 5×2+2 fonksiyonunun x=4.8 noktasındaki değerini main() { float x, y ; x = 4.8; y = 5 * x * x + 2; } Örnek 2.7.2: Vize ve final notlarınından geçme notu main() { float vize, final, ort; vize = 50; final = 60; ort = vize * 0.4 + final * 0.6; } Örnek 2.7.3: 1998 yılına kadar geçen gün sayısı main() { float gun; int yil = 1996; gun = 365 * (yil – 1); gun = gun + (yil -1 ) / 4; }

2.8 printf işlevi
Program içinde istenen değerleri çıktı birimlerine göndermek için kullanılır. Normal kullanımında çıktı birimi olarak ekran kabul edilir. Kullanım biçimi:

prinf( kontrol, )
ile belirtilen bilgiye göre parametreleri yazar. Kontrol metini iki kısımdan oluşur.
o sıradan karakterler: doğrudan yazılırlar.
o dönüşüm/biçim belirleyici karakterler: Değerlerin nasıl yazılacağı bildirilir.

printf(” sonuç = %d”, k);
— integer değer yazılacaktır
——— ekrana aynen aktarılır

Dönüşüm belirlemek için önce % karakteri ve ardından dönüşümün nasıl
olacağını belirten karakter verilir. Bu karakterlerden bazıları:

d : decimal (integer)
u : unsigned decimal
c : char (tek karakter)
s : string
e : float/double sayıyı bilimsel gösterimde yaz
f : float/double sayıyı [-] mmm.nnnnn biçiminde yaz
ld : long integer
lu : unsigned long integer
Le,Lf : long double

ESC dizileri : \n : satır başı, \a : zil , \t : tab, \b : bir karakter geri

program parçası ekranda görünen / imleçin konumu
i = 5 ;
printf(“%d”,i) ; 5
printf(“‘i=%d”,i) ; i=5
printf(“i=”) ;
printf(“%d”,i) ; i=5 -

printf(“i=\n”) ; i=
printf(“%d”,i) ; 5 alt satıra geçer

printf(‘i=%d\n”,i) ; i=5 alt satıra geçer

printf(“%d – %d”,i, 5*i); 5 – 25

Biçimli yazdırma
% karakteri ile dönüşüm karakteri arasına aşağıdaki karakterler de kullanılabilir.

– : sola dayalı yaz
m : yazılacak değer için ayırılan alan
n : değerin kaç karekteri yazılacağı

s = “ABCDEF”
printf(“%10s “,s); . . . . A B C D E F

printf(“%10.3s “,s); . . . . . . . A B C

x = 128.5 ;
printf(“%7.2f”,x) ; # 128.50

x = 85.47 ;
printf(“%6.3f”,x) ; 85.470

printf(“%6.1f”,x) ; ## 85.5

Örnek 2.8.1 : Yarıçapı belli dairenin alanını hesaplayan programı yazınız. (ilk yazılan program)
#include
main()
{
const float PI=3.14;
float r, alan;
r = 7;
alan := PI*r*r;
printf((‘Alan = %f’, alan);
}

Örnek 2.8.2 : En fazla dört basamak olabilen sayının basamak değerlerini yazdır. % ve / işlemlerinin kullanımı.
#include
main()
{
int i,y;

y=1985;
i= y / 1000;
printf(“%d”,i);
y= y-i*1000;
i= y / 100;
printf(” %d”,i);
y = y-i*100;
i= y / 10;
printf(” %d”,i);
y = y-i*10;
printf(” %d\n”,y);
i = 1985;
printf(“%d “,i / 1000);
printf(“%d “,(i / 100) % 10);
printf(“%d “,(i / 10) % 10);
printf(“%d\n”,i % 10);
}

Örnek 2.8.3: ax2+bx+c=0 tipi bir denklemin köklerini veren programı yazınız.
Girdi : a, b ve c katsayıları
Çıktı : denklemim kökleri
Algoritma :
1. a, b ve c katsayılarını oku.
2. Delta= değerini hesapla.
3. x1 ve x2 değerlerini hesapla.
4. Kökleri yaz.

Programın kodlanması:

#include /* printf işlevi için */
#include
/* sqrt işlevi için */
main()
{
float a, b, c;
float x1, x2;
float d;

a = 1;
b = -3;
c = 2;
d = b * b – 4 * a * c;
x1 = (-b + sqrt(d)) / (2 * a);
x2 = (-b – sqrt(d)) / (2 * a);

printf(“Kökler = %f , %f”,x1, x2);
}
C dilinde karekök almak için bir deyim yoktur. Örnekte bunu yerine getiren C diline eklenmiş olan sqrt() fonksiyonu kullanılmştır. Aşağıda buna benzer artık C derleyecilerinde standart olmuş bazı fonksiyonlar verilmiştir. Bu işlevler math.h başlık dosyasında tanımlıdır.
Fonksiyon x ,y Sonuç
abs(x) int int x’in mutlak değeri
fabs(x) double double x’in mutlak değeri
pow(x, y) double double xy
sqrt(x) double double x’in karekökü
exp(x) double double ex değeri
log(x) double double ln(x) değeri
log10(x) double double log10(x) değeri
ceil(x) double double x ten büyük ilk tamsayı
floor(x) double double x ten küçük ilk tamsayı

Örnekler:
ceil(5) 5
ceil(5.2) 6
ceil(-5.2) -5
floor(5) 5
floor(5.2) 5
floor(-5.2) -6

2.9 scanf İşlevi
Klavyeden veri okumak için kullanılır. Yapı olarak printf işlevi ile hemen hemen aynıdır. Kullanım biçimi:

scanf( kontrol, )

Girilen karakterler metininde belirtilen biçimlere göre değişkenlere aktarılır.
Değişkenler işaretçi tipinde olmalıdır. Yani parametre olarak değişkenin adresi gönderilmelidir.
Ayırıcılar boşluk, tab, enter

scanf(“%f %f %f “, &a, &b, &c);

scanf işlevinin değeri
0 ise hiçbir değişkene değer atanmamış
>0 ise başarılı bir şekilde değer atanan değişken sayısı
int a,b,c;
float m,n;
scanf(“%d”, &a); Klavyeden tamsayı okur. Girilen değer a değişkenine aktarılır.
scanf(“%d %d”,&a,&b) Klavyeden girilen ilk değer a değişkenine, ikinci değer b değişkenine aktarılır.
scanf(“%f %d”, &m, &a); Klavyeden ilki gerçel, ikincisi tamsayı olmak üzere iki değer okur.

İkinci dereceden denklem çözümünün yapıldığı örnekte katsayıları klavyeden okutmak istersek

scanf(“%f %f %f “, &a, &b, &c);

Farklı kullanıcı arayüzünde yazarsak

printf(“Katsayıları sırasıyla giriniz (a b c) :” ); scanf(“%f %f %f “, &a, &b, &c);

printf(“a katsayısını giriniz : “); scanf(“%f”, &a);
printf(“b katsayısını giriniz : “); scanf(“%f”, &b);
printf(“c katsayısını giriniz : “); scanf(“%f”, &c);

Örnek 2.9.1: Vize ve final notlarınından ortalamayı hesaplayan programda değerlerin klavyeden okunmuş hali.
main()
{
float vize, final, ort;
printf(“Vize notunu giriniz “); scanf(“%f”, &vize);
printf(“Final notunu giriniz “); scanf(“%f”, &final);
ort = vize * 0.4 + final * 0.6;
printf(“Ortalaması = &f\n”, ort);
}

2.10 Mantıksal ifadeler
Sonucu Doğru veya Yanlış olan ifadelerdir. Sonuç sıfır ise yanlış aksi halde doğru kabul edilir.
İlişkisel işleçler(operatör) : iki değer arasındaki ilişkiyi test etmek için kullanılır.
işleç anlamı
> büyük
>= büyük – eşit
== eşit
< küçük
<= küçük - eşit
!= eşit değil

x=8, y=5 için
x > y Doğru
x < y Yanlış
x !=y Doğru

Mantıksal işleçler : İki mantıksal ifade arasındaki ilişki üzerindeki ilişkide kullanılır.
! DEĞİL (NOT)
&& VE (AND)
|| VEYA (OR)

(X>0) && (X>Y)
(X>0) || (Y>0)

İfadelerde işleçlerin yürütülme sırası
işleç Önceliği
( ) en yüksek (ilk yürütülür)
!
*, /, %
+, –
<, <=, >=, >
==, !=
&&, ||
= en düşük (son yürütülür)
= işleci sağdan sola, diğerleri soldan sağa doğru yürütülür.
Görüldüğü gibi ifadelerde matematiksel ve mantıksal işlemler bittikten sonra ilişki test edilir.
X=50, Y=80, Z=45 için
( ( X / 4 + Y / 4 + Z / 2 ) >= 50 ) && ( Z >= 50 )

3 – Döngü ve Koşul Deyimleri

Programlar (algoritmalar) üç temel blok kullanılarak gerçekleştirilebilirler. Bunlar; ardarda, bir koşula bağlı olarak ve sonlu sayıda yineleme (döngü) dir.

3.1 Koşul Deyimleri

Birkaç seçenekten birini seçmek veya bir deyimin bir koşula bağlı olarak işlemek için kulanılır.

3.1.1 if-then-else Deyimi

if ()
blok_doğru;
else
blok_yanlış;

Mantıksal ifade doğru ise blok_doğru, yanlış ise else sözcüğünden sonraki blok_yanlış yürütülür. else kısmı seçimlidir, gerekmiyorsa kullanılmayabilir.

Örnek 3.1. 1.1 Girilen sayının tek/çift olduğunu yazan program
#include
main()
{
int i;
scanf(“%d”, &i);
if ( i % 2 == 1)
printf(“Tek”);
else
printf(“Çift”);
}

Bileşik (Compound) Deyimler

{ ve } karakterleri ile sınırlandırılmış bir dizi deyimden oluşur.
{
i = 5;
j = i/2;
k = i+1;
}

Eğer bloklarda birden fazla deyim kullanmak gerektiğinde bileşik deyim kullanılır.

if (yil % 4 == 0) {
subat =29;
gunyil = 366;
}
else {
subat =28;
gunyil = 365;
}
Örnek 3.1.1.2 : İkinci dereceden denklemin köklerinin bulunması.

if (delta<0)
printf("Gerçel kök yoktur.\n");
else
{
x1 = (-b + sqrt(delta)) / (2 * a);
x2 = (-b - sqrt(delta)) / (2 * a);
printf("Birinci kök = %f\n" , x1);
printf("ikinci kök = %f\n" , x2);
}

Örnek 3. 1.1.3 : Klavyeden girilen karakterin rakam olduğunun tesbiti.

char c;
c = getch();
if ((c>=’0′) && (c<='9')
printf("Rakam girdiniz.");

Örnek 3. 1.1.4 : Girilen üç sayıdan en küçüğünün bulunması (İçiçe IF kullanımı).

scanf("%d%d%d", &s1, &s2, &s3);
if ((s1 ek =s1;
else
if (s2 ek =s2;
else
ek = s3;
printf('En küçük olanı = %f", ek);

II. yol :
scanf("%d%d%d", &s1, &s2, &s3);
ek = s1;
if (ek>s2)
ek =s2;
if (ek>s3)
ek =s3;
printf(‘En küçük olanı = %f”, ek);

Örnek 3. 1.1.5: Fonksiyonun girilen t değeri için aldığı değeri hesaplayıp yazan program.

main() { float y, x; printf(“x değerini giriniz”); scanf(“%f”, &x); if (x > -1 && x<2) y = 2/3 * (x + 1); else if (x>2 && x<=3) y = 2; else y = 0; printf(“Fonksiyonun değeri = &f”, y); }

Örnek 3. 1.1.6: Vergi iadesini hesaplan programı yazınız. (elseif yapısı)
(0-60 bin : %10, 60-120 bin : %,120-200 bin : %12,>200 bin : %5)

main()
{
float fat_top, vergi_iade;
printf(“Fatura toplamlarını giriniz “);
scanf(“%f”, &fat_top);
if (fat_top < 60000)
vergi_iade = fat_top * 0.10;
else if (fat_top < 120000)
vergi_iade = 6000 + (fat_top - 60000) * 0.20;
else if(fat_top < 200000)
vergi_iade = 18000 + (fat_top - 120000) * 0.12;
else
vergi_iade = 27600 + (fat_top - 200000) * 0.05;

printf("Ödenecek vergi iadesi = %f\n", vergi_iade);

}

Örnek 3. 1.1.7: Girilen tarihteki günün adını veren programı yazınız.

#include
main ( )
{
int gun, ay, yıl ;
long gt ;
printf(“Tarihi gir”) ; scanf ( “%d %d %d “,&gun)

/* oncekı yıllardakı gun sayısını hesapla */

gt=( yıl*1)*365 + yıl/4;

/* bu yildaki aylardaki gunleri ekle */

if (ay==2)
gt = gt + 31 ;
else if (ay ==3)
gt = gt + 31 + 28 ;
else if (ay ==4)
gt = gt + 31 + 28 +31;
else if (ay ==5)
gt = gt + 31 + 28 +31+ 30 ;
else if (ay ==6)
gt = gt + 31 + 28 +31+ 30 +31;
else if (ay ==7)
gt = gt + 31 + 28 +31+ 30 +31+ 30 ;
else if (ay ==8)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31 ;
else if (ay ==9)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31+30 ;
else if (ay ==10)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31+30 + 31;
else if (ay ==11)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31+30 + 31+ 30 ;
else if (ay ==12)
gt = gt + 31 + 28 +31+ 30 +31+ 30 + 31+30 + 31+ 30 +31;

/*Bu ayı ekle */
gt = gt+ gun;
if(yıl%4==0 && ay>2),
gt =gt+1;
gt=gt %7,
if(gt==1)
printf(“Pazar”);
else if(gt==2)
printf(“Pazartesi”);
else if(gt==3)
printf(“Salı”);
else if(gt==4)
printf(“Carsamba”);
else if(gt==5)
printf(“Persembe”);
else if(gt==6)
printf(“Cuma”);
else if(gt==7)
printf(“Cumartesi”);
}

3.1.2 switch Deyimi

switch() {
case seçenek1 : Deyim;
case seçenek2 : Deyim;
.
.
.
default : Deyim;
}

Seçicinin aldığı değere eşit seçeneğin olup olmadığına bakar. Var ise o noktadan sonraki deyimler yürütülür. switch deyiminin sonuna gelindiğinde veya break deyimi ile karşılaşıldığında yürütme işlemi durur ve programın akışı switch deyimini izleyen deyim ile devam eder.

switch(i) {
case 1 : printf(“Bir”);
case 2 : printf(“İki”);
default : printf(“Hiçbiri”);
}

i=1 ise çıkış BirİkiHiçbiri
i=2 ise çıkış İkiHiçbiri

Sorunu ortadan kaldırma için her durum için break deyimi eklenmeli.

. Seçici Ordinal tiplerden biri olmalıdır (Ordinal tip: tüm değerleri listelenebilinen veri tipleri – integer, char).
. Seçici ile seçenekler aynı tipte olmalıdır.
. default kısmı seçimliktir. Seçeneklerin hiçbiri uygun değil ise yürütülür.

#include
main()
{
char islem;
int s1, s2, s3;
printf(“Önce işlemi sonra sayıları girin “);
scanf(“%c%d%d”,&islem, &s1, &s2);
switch (islem) {
case ‘+’ : s3 = s1 + s2; break;
case ‘-’ : s3 = s1 – s2; break;
case ‘*’ : s3 = s1 * s2; break;
case ‘/’ : s3 = s1 / s2; break;
default : printf (“Hatalı işlem”);
}
printf(“\nSonuç = %d”,s3);
}

Örnek 3.1.2.1: Mevsimleri yaz.

scanf(“%d”, &ay);
switch (ay) {
case 3:
case 4:
case 5: printf(“ilkbahar”); break;
case 6:
case 7:
case 8: printf(“yaz”); break;
case 9:
case 10:
case 11: printf(“sonbahar”); break;
case 12:
case 1:
case 2: printf(“kış”); break;
}
switch deyimi yerine if deyimi kullanılabilir. Ancak switch deyimi programı daha okunabilir kıldığı için gerekli olduğu durumlarda kullanılmalıdır.

Örnek 3.1.2.2 : 16′lık sistemdeki rakamın 10′luk sistemdeki karşılığı (char tipinin sayı gibi davranışı).
switch(c) {
case ’0′:
case ’1′:
. . .
case ’9′: i = c – ’0′; break;
case ‘a’:
case ‘A’: i = 10; break;
. . .
case ‘f’:
case ‘F’: i = 15; break;
}

Örnek 3.1.2.3: Sınav notunu harfe dönüştüren programı yazınız.
( >=90 :AA, 85-89:BA, 80-84:BB, 75-79:CB, 70-74:CC, 60-69:D, <60 :F )

Örnek 3.1.2.4: Belirtilen tarihin hangi güne denk geldiğini bulan programı yazınız.
else if yapısı yerine switch kullanarak

3.2 Döngü Deyimleri (Yineli)

Bir ya da birden fazla deyimin tekrar edilemesini sağlarlar. C dilinde while, for ve do-while deyimleri döngü işlevini saşlar. Tekrar edilen deyimlere döngü gövdesi denir.

3.2.1 while Deyimi

while
Deyim

Mantıksal ifade doğru olduğu sürece Deyim yürütülür. Eğer yanlış ise kontrol bir sonraki deyime geçer.

Örnek 3.2.1.1 : 1′den 100′e kadar olan sayıların toplamı.

i =1 j = 0 i < 101 olduğu sürece j = j + i i = i + 1 4. Toplam j ‘ yi yaz main() { int i, j; i =1; j = 0; while (i<101) { j =j+i; i =i+1 } printf("Toplam = %d",j); }

Örnek 3.2.1.2: Toplama ve çarpma kullanarak çarpma işmeini gerçekleyiniz.
a ve b sayılarını oku c =0 b>0 olduğu sürece tekrarla .3.1. c=c + a 3.2. b = b-1 4. c değerini yaz ve dur main() { int a, b, c; printf (“iki sayıyı giriniz “); scanf(“%d%d”, &a, &b); c = 0; while (b > 0) { c = c + a; b = b – 1; } printf(“Sonuç = &d\n”, c); }

Örnek 3.2.1.3: Girilen sayının faktoriyelini hesaplayan programı yazınız.
n değerini oku F=1 n >1 olduğu sürece tekrarla .3.1. F=F*n 3.2. n= n-1 F değerini yaz main() { int n; long f; printf (“sayıyı giriniz “); scanf(“%d”, &n); f = 1; while (n > 1) { f = f * n; n = n – 1; } printf(“Sonuç = &d\n”, f); }

Örnek 3.2.1.4: Klavyeden girilen sayıları oku. Sayıların toplamı 21′den büyük veya eşit olduğu zaman dur.
main()
{
int i, j = 0;
while (j<21) {
scanf("%d",&i);
j =j+i;
}
printf("Toplam = %d",j);
}
Örnek 3.2.1.5: 1993 yılı itibarı ile ülke nüfüsu 60 milyondur. Yıllık nüfüs artış oranı %2.3 tür. Sonraki 10 yılda ülke nüfüsunu yıllara göre listeleyen program.

/* Nufus Tablosu */
#include
main()
{
int i; /* sayac */
int yil; /* yillar */
float nufus; /* nufus miktari */
float artis; /* artis orani */

artis = 0.023;
yil = 1993;
nufus = 60000000;
printf(“%d – %10.0f\n”,yil,nufus);
i = 1;
while (i < 11)
{
nufus = nufus * (1 + artis);
printf("%d - %10.0f\n",yil + i,nufus);
i = i + 1;
}
}

Örnek 3.2.1.6 : Girilen tamsayının mükemmel sayı olup olmadığının söyleyen programı yazınız.
(mükemmel sayı = tam bölenlerin toplamı sayının kendisine eşit)

Örnek 3.2.1.7 : Girilen tamsayının kaç basamaktan oluıştuğunu söyleyen programı yazınız.

Örnek 3.2.1.8 : Girilen tamsayı içerisinde kaç tane 1 olduğunu söyleyen programı yazınız.

Örnek 3.2.1.9: Girilen tamsayının son üç basamağını yuvarlayan programı yazınız.
son üç basamağı >=500 > 1000 e, <500 ise 0 a yuvarlayacak
(2560  3000, 2490  2000 )

Örnek 3.2.1.10: Sınavın ortalamasını hesaplayan programı yazınız.
1 Durum : sınava giren öğrenci sayısı belli

main()
{
int i, ogr_say, not_top, not;
float ort;
not_top = 0;
i = 0;
printf(“Öğrenci sayısını giriniz “); scanf(“%d”, &ogr_say);
while (i < ogr_say) {
printf”Sıradaki öğrencinin notu = “); scanf(“%d”, &not);
not_top = not_top + not;
i = i + 1;
}
ort = float (not_top) / ogr_say;
printf(“Ortalama = &f\n”, ort);
}
2 Durum : sınava giren öğrenci sayısı belli değil

Bu durumda girişin bittiğini gösterir bir bilgiye (işarete) ihtiyaç vardır. Sınav notu için 0 dan küçük bir değer girildiğinde girme işleminin sona erdiğinin varsayalım.

ogr_say = 0;
printf”Sıradaki öğrencinin notu = “); scanf(“%d”, &not);
while (not >= 0) {
not_top = not_top + not;
ogr_say = ogr_say + 1;
printf”Sıradaki öğrencinin notu = “); scanf(“%d”, &not);
}

3.2.2 For Deyimi

for (ifade1 ; ifade2 ; ifade3 )
ifade;

ifade2 doğru ( veya farklı 0) olduğu sürece ifade yürütülür (bitiş koşulu).
Döngünün ilk adımından önce ifade1 yürütülür ( başlangıç adımı).
Döngünün her adımında ifade3 yürütülür (artış miktarı).

for (i = 1; i < 5; i++)
printf("%d ",i);

ifade1, ifade2 ve ifade3 seçimliktir. ifade2 belirtilmez ise herzaman
doğru olduğu ( == 1 ) kabul edilir. Yani sonsuz döngü oluşur.

for (i = 1; ; i++)
printf("%d ",i);

Örnek 3.2.2.1: 1'den 100'e kadar olan sayıların toplamı.

j =0;
for (i=1; i<=100; i=i+1)
j =j+i;
printf("Toplam %d",j);

Örnek 3.2.2.2: Girilen sayının faktöriyelini bulunuz.

fact =1;
for (j=1; j<=i; j++)
fact =fact*j;
printf("Faktöriyel =%f",fact);
}

Örnek 3.2.2.3: Çarpım tablosu. (içi içe döngüler)

main()
{
int i,j;
for (i=1; i<=10; i++) {
for (j =1; j<=10; j++)
printf("%4.0d",i*j);
printf("\n");
}
}

Örnek 3.2.2.4: ? işlevini çiziniz(0-8 noktaları arasında).

3.2.3 do-while Deyimi

Bir koşul doğru olana kadar döngü yürütülür.

do
Deyim
while ()

Mantıksal ifade doğru olduğu sürece döngü tekrar edilir. Yanlış olduğunda while sözcüğünden
sonraki deyim yürütülür.

5 sayısı girilene kadar oku

do
scanf(“%d”,&i);
while (i!=5);

i =1;
do {
printf(“%d”,i*i);
i =i+1;
} while (i<=10);

Örnek 3.2.3.1: Sadece +, - kullanarak * işlemini gerçekleştirme.

main()
{
int a, b;
int c;
scanf("%d%d", &a, &b);
c = 0;
do {
c = c + a;
b = b - 1;
} while (b>0);
printf(“%d\n”, c);
}
Karşılaştırma
while : Koşul başlangıçta test ediliyor. Döngü sıfır veya daha fazla yürütülüyor.
do-while : Koşul sonda test ediliyor. Döngüye en az bir defa kesin giriliyor.

Örnek 3.2.3.2: 0 – 100 arasında tutulan sayının tahmini.
main()
{
int tahmin; /* tahminimiz */
int min; /* Tahminin alt siniri */
int max; /* Tahminin ust siniri */
char cevap; /* Kullanicinin cevabi */
min = 0; max = 100;
do {
tahmin = (max – min) / 2 + min;
printf(“Tahminim %d\n”,tahmin);
printf(“Buyuk / Kucuk / Esit “);
scanf(“%c”,&cevap);
if (cevap == ‘B’)
max = tahmin – 1;
else
if (cevap == ‘K’)
min = tahmin + 1;
} while (cevap != ‘E’);
}
Örnek 3.2.3.3: Sin(x) fonksiyonun belli bie x için değerini seri açılımı ile hesaplayınız. Serinin ilk 10 terimini kullanınız. n tek sayı.
main()
{
float x; /* fonksiyonun hesaplanacağı değer */
float sinx; /* sin(x) in değeri */
float xt; /* eklenen terimin payı */
float fakt; /* eklenen terimin paydası, faktoriyel */
int isaret; /* terimin +/- olmasını sağlar */
int i;
clrscr();
printf(“Hesaplanacak değer : “);
scanf(“%f”,&x);
sinx = x;
isaret = -1;
fakt = 1;
xt = x;
for (i = 2; i<=10; i++) {
xt = xt * x * x;
fakt = fakt * (2 * i - 2) * (2 * i - 1);
sinx = sinx + isaret * xt / fakt;
isaret = -isaret;
}
printf("Değeri = %f\n",sinx);
}
Örnek 3.2.3.4 : Aynı örneği belli sayıda terim için değil, sonucu 4 basamak hassasiyetle hesaplayınız.
4 - İşlevler

Problem çözmenin ilkelerinden biri problemi mümkün olduğu kadar çok parçaya bölmek idi. Daha sonra bu parçalar bağımsız olarak düşünülüp çözümleri elde edilebilir. C'de bu bölme işlemi işlev kullanarak yapılır.
Belli bir işi gerçekleştiren program deyimlerinin karmaşık programları düzenlemek ve basitleştirmek için programın bir birimi olarak gruplandırılması.

(işlev kullanmanın temel nedenleri : divide and conquer , software reusability )

Örnek 4.1 : Bir tamsayının faktöriyelini hesaplayan işlev

main() { int i; prinf(“Sayıyı giriniz “); scanf(“%d”, &i); printf(“%d\n”, fakt(i)); } long fakt ( int n) { int j; long f = 1; for ( j = 2; j < =n; j = j + 1), f = f * j; return f; }

Örnek 4.2 : Bir tamsayının kübünü veren işlev
#include
main()
{
int sayi;
int kub(int); /* işlevin prototipi */

printf(“sayıyı gir “);
scanf(“%d”, &sayi);

printf(“Kübü = %d\n”, kub(sayi));
}

int kub(int i)
{ return i*i*i; }

İşlevin tanımlanma biçimi

dönüş_tipi işlev_adı(parametreler)
{
yerel tanımlamalar
deyimler
}

dönüş_tipi: Eğer işlev bir değer geri gönderecek ise değerin tipini belirtir. Belirtilmez ise Int kabul edilir. Eğer işlev değer göndermeyecek ise dönüş_tipi yerine void yazılır.

işlev_adı: İşlev çağırılırken kullanılacak ad (belirleyici).

parametreler: İşlev için gerekli değerleri içerir. Her parametre değişken tanımlar gibi tanımlanır. Herbirinin arasında ‘,’ kullanmak gerekir.
yerel tanımlamalar: Bu işleve özgü(değişken,sabit) tanımlamalar.

Eğer işlev bir değer gönderecek ise bu return deyimi ile yapılır.

return değer;

İşlevin Prototipi
Tanımlana bir işlevin ana modül içerisinde prototipinin yazılması gerekir. Prototip ile işlevin dönüş değeri ve aldığı parametrelerin tipleri tanımlanır. Bu bilgiye göre C derleyecisi işlev çağırıldığında değerlerin uygun olduğunu sınar.
int kub(int) kub işlevi int bir değeri alır ve yine int bir değer üretir.

Örnek 4.3 : Üç sayıdan en büyüğünü veren işlev.
Girdi : üç tane tamsayı
Çıktı : girdilerin en büyüğü

int max(int s1, int s2, int s3)
{
if (s1>s2 && s1>s2)
return s1;
else
if (s2>s3)
return s2;
else
return s3;
}

Bu işlevi kullanan bir program
#include
main()
{
int max(int, int, int);
clrscr();
printf(“%d \n”, max(1,2,3));
printf(“%d \n”, max(14,8,12));
printf(“%d \n”, max(1,6123,3123));
}
…
işlevin tanım bloğu
…

Örnek 4.4: Üs alma işlevini gerçekleyen işlev (üs bilgisi tamsayı).
Girdi : taban ve üs değeri
Çıktı : tabanın üs. kuvveti
float us (float a, int b)
{
int i;
float r;

r = 1;
for (i = 1; i<=b; i++)
r = r * a;
return r;
}

Fonksiyonun program içinden çağırılışı
d = us(2,3);
d = us(a, 4);
d = d * us(3,4);

Üs alma işlemini gerçeklemenin diğer yolu

ab = eblna = Exp(b * Ln(a))
Exp(x : Real) : Real ex
Ln(x : Real) : Real Ln(x)

float us (float a, float b)
{
if (a>0)
return= exp( b * log (a ));
else
return= -1;
}

Genel değişken (global): Her yerde (main ve diğer işlevler) geçerlidir, değerine erişilebilir.
Programın en başında, main işlevinin dışında tanımlanır.
Yerel değişken (local): Sadece tanımlandığı modülde geçerlidir, değerine erişilebilir.
Modül içinde tanımlanır.

int a; /*tüm işlevlerden değerine erişilebilir, değeri değiştirilebilir. (global) */

main()
{
int b; /* sadece main işlevi içerisinden erişilebilir (local ) */
…
}

islev1(…);
{
int b; /* sadece islev1 işlevi içerisinden erişilebilir. main işlevindeki değişkendan bağımsızdır (local ) */
int c; /* sadece islev1 işlevi içerisinden erişilebilir (local ) */
…
}

Örnek 4.5 : 8 bit olarak girilen bir sayıya eşlenik (parity) bitini ekleyen programı yazınız (çift eşlenik)
Eşlenik biti en düşük anlamlı bit olarak eklenecektir.

Algoritma
1. Sayıyı oku.
2. Sayıdaki birlerin sayısını bul.
3. Birlerin sayısı tek ise 1, çift ise 0 ekle.

Programı yazarken 2. ve 3. adımlar işlev olarak yazılacaktır.

/* Eşlenik biti ekleme */
int bulbir ( int );
int eklebir ( int , int );

main()
{
int girsayi, birler;

clrscr();
scanf(“%d”, &girsayi);
birler = bulbir(girsayi);
girsayi = eklebir(birler, girsayi);
printf(“%d\n”, girsayi);
}

int bulbir ( int sayi)
{
int kacbir = 0;
while (sayi>0) {
kacbir = kacbir + (sayi % 2 );
sayi = sayi / 2;
}
return kacbir;
} /* BulBir */

int eklebir ( int birler, int sayi)
{
return (2 * sayi + (birler % 2));
} /* Eklebir */

* Karşı taraf için gereken algoritmayı yaz (sayı doğru mu, doğru ise değeri).

Örnek 4.6 : A işyerindeki bir personelin hangi dilimden gelir vergisi ödeyeceğini (yüzdesini) belirten fonksiyonu yazınız.

Girdi : personelin birikmiş vergi matrahı
Çıktı : Kesinti yüzdesi
İlgili bilgi : 0-20 Milyon %25, 20-40 Milyon %30, 40-80 Milyon %35, 80-160 Milyon %40
>180 Milyon %45

int v_oran ( float bvd);
{
int i;
if (bvd < 20000000)
i = 25;
else if (bvd < 40000000)
i = 30;
else if (bvd < 80000000)
i = 35;
else if (bvd < 160000000)
i = 40;
else
i = 45;
return i;
}
Örnek 4.7 : Gelir vergisi matrahı ve önceki aylara ait birikmiş vergi matrahı belli bir personelin gelir vergisini hesaplayan fonksiyonu yazınız.
Vergi := Gelir vergisi matrahı * Vergi oranı
Not : Eğer personel bu ay dilim değiştiriyorsa gelir vergisi gerektiği şekilde eski ve yeni dilime paylaştırılarak kesinti hesaplanmalıdır.

Örnek 4.8 : Girilen harfi büyük harfe dönüştüren fonksiyon
Girdi : karakter
Çıktı : karakter ( girdi harf ise büyük harfe dönüştürülmüş)

char buyuk(char c);
{
if (c >= ‘a’ && c <= 'z')
return c - 32;
else
return c;
}

Örnek 4.9:
Girdi : iki sayı ve aralarındaki işlem
Çıktı: iki sayı arasındaki işlemin sonucu

int calculate(char islem, int a, ibt b, int c)
{
int s;
switch( islem )
case '+' : s = a + b ; break;
case '-' : s = a - b ; break;
case '*' : s = a * b ; break;
case '/' : s = a / b ; break;
default : s = 0;
}
return s;
}

Çağırma biçimi
a = calculate ('+',4,8');
a = calculate ('/', 4,2) * calculate ('*', 2,2);

Örnek 4.10: Bir işlevin köklerinden birini Newton yönetimi ile bulan prg. ( x2-2 )

#include
#include

double fn(double);
double fnt(double);

main()
{
double x,x0;
double hata;

hata = 0.0001; /* izin verilen hata */
x = 8; /* başlangıç değeri */
do {
x0 = x;
x = x0 – fn(x0)/fnt(x0);
} while (fabs(x-x0)>hata);

printf (“Sonuç = %f\n”, x);
printf (“f(x) = %f\n”, fn(x));
}

double fn(double x) /* işlevin değeri */
{
return x*x-2;
}

double fnt(double x) /* işlevin türevinin değeri */
{
return 2*x;
}

Örnek :4.11: İki sayının ortak katlarının en küçüğünü veren işlevi yazınız.

#include
long okek(long, long);
main()
{
long i, j;
clrscr();
printf(“İki tamsayı giriniz :”);
scanf(“%ld%ld”, &i, &j);
printf(“sayıların okeki = %ld \n” okek(i, j));

}

long okek(long p, long q)
/* p < q olmali. Degil ise yerlerini değiştir. */
{
long i, k;
if (p>q) {
i=p;
p=q;
q=i;
}

/* p nin öyle bir katını bul ki q sayısına tam bölünsün
2 sayısından itibaren taranmaya başlanabilir fakat
p/q yeterli
*/

i = q / p;
do {
k = p*i;
i = i+1;
} while ( k % q != 0);
return k;

Örnek :4.12: İstenen sayıdaki asal sayıyı listeleyen programı yazınız.

#include

int asal(int);
main()
{
int i ; /* asal olup olmadığı sınanacak sayılar */
int kac; /* ilk kaç asal sayının listeleneceği bilgisi */
int j; /* listelenen asal sayıların adetini tutar */

clrscr();
printf(“ilk kaç asal sayı listelenecek : “);
scanf(“%d”, &kac);

/* for deyiminde ifade3 kısmında döngü değişkeni yerine
farklı bir değişkenin değeri değiştiriliyor. Döngü değişkeni
ide incelenen sayı asal ise arttırılıyor
*/

i = 2;
for (j = 1; j<=kac;i++)
if (asal(i)) {
printf("%d \n", i);
j++;
}
}
int asal(int n)
/* sayı asal ise 1 değilk ise 0 değerini alır */
{
int i;
if (n % 2 == 0)
return (n==2);
if (n % 3 == 0)
return (n==3);
if (n % 5 == 0)
return (n==5);
for (i=7; i*i <= n; i+=2)
if (n % i == 0)
return 0;
return 1;
}

Örnek :4.13: Belirtilen tarihteki ayın kaç gün sürdüğünü veren işlevi yazınız.
Girdi : Ay ve yıl
Çıktı : Aydaki gün sayısı

int aydakigun(int ay, int yil)
{
int i;
switch (ay) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12 : i = 31;break;
case 2 :
if (yil % 4 == 0)
i = 29;
else
i = 28;
break;
default : i = 30;
}
return i;
}

Örnek :4.14: Önümüzdeki yılda Ramazan Bayramı nın hangi tarihte kutlanacağını hesaplayan programı yazınız. Bu yılki tarih klavyeden gün ay ve yıl olarak okunacakır.
Girdi: Bu yıl kutlanılan tarih
Çıktı : Sonraki tarih

#include

int aydakigun(int, int);

main()
{
int gun,ay, yil;
int i, j ;

clrscr();
printf(“Bu yılki tarihi giriniz (G A Y) : “);
scanf(“%d %d %d”,&gun, &ay, &yil);
yil = yil + 1;
gun = gun – 11;
if (gun < 1 ) {
ay = ay - 1;
if (ay < 1 ) {
ay = 12;
yil = yil - 1 ;
}
gun = gun + aydakigun(ay, yil);
}
printf("\nGelecek bayram = %d/%d/%d\n",gun,ay,yil);
}

Örnek :4.15: Girilen bir tamsayının basamaklarının sırasının tersinin oluşturduğu sayıyı veren işlevi yazınız.
#include
long tersi(long);
main()
{
long s;
clrscr();
printf(“Sayıyı giriniz : “);
scanf(“%ld”, &s);
printf(“Basamaklarının ters çevirilmişi = %ld \n”, tersi(s));
}

long tersi(long k)
{
long a, b;
a = 0;
while (k>0) {
b = k % 10;
a = a * 10 + b;
k = k / 10;
}
return a;
}

4.2 Özyineleme (Recursive) İşlevler

Kendini çağıran fonksiyonlardır.

Örnek 4.2.1: Faktoriyel hesabı

long fakt(long i)
/* fakt = i! */
{
if (i<2)
return 1;
else
return i*fakt(i-1);
}

Örneğin n=4 için fonksiyonun kendisini çağırdığı satır şöyledir:
4 * fakt(3), 3 * fakt(2), 2 * Fakt(1)
24 = 4 * 6 <-- 3 * 2 <-- 2 * 1

Örnek 4.2.2: Ortak bölenlerin en büyüğünü bulan program (Euklid yöntemi).
gcd = greatest common divisor

long gcd (long m, long n )
/* m ve n sayılarının ortak bölenlerinin en büyüğü*/
{
if (n == 0)
return m;
else
return gcd( n, m % n);
}

Örnek 4.2.3: İki sayı göreceli asal olup olmadığını veren fonksiyon (relativeli prime = gcd() = 1 )

Örnek 4.2.4: Sayının 9 un katı olup olmadığının basamak toplamlarının 9 olması ile bulunması (Özyinelemeye örnek olsun)

int kati9(long s)
{
int t;
if ( s < 10)
return ( s == 9);
else {
t = 0;
while ( s > 0) {
t = t + s % 10;
s = s / 10;
}
s = kati9(s);
}
}

5- Diziler

Şu ana kadar basit değişkenler kullandık ( her değişkinin bir değeri var).

Yapısal değişken: benzer verilerin tek bir değişken altında gruplandırılması.

Dizi veri yapısı: Aynı tip verilerin toplanıp tek isim verilmesi.

5.1 Dizi Tanımı ve Kullanımı

Tip_Adı değişken[boyut];

Örneğin

float a[100];

Bu tanımlama ile a isimli değişkeni 100 gerçel değerin saklandığı bir diziyi gösterir. Bu 100 veriye a değişkeni ile erişilir.

Dizinin herhangi bir elemanına erişmek veya değiştirmek için kaçıncı eleman olduğunu gösterir indis bilgisini vermek gerekir. İlk elemanın indisi 0 dır.

A[4] dizinin 5. elemanı
A[0] dizinin ilk elemanı
A[1] := 45; dizinin 2. elemanına 45 atanır
A[7] := A[7] + A[1]; dizinin 8. elemanına kendisi ile 2. elemanın toplamı atanır

Dizinin eleman değerler tanımlama anında yapılabilir.
int a[10] = {25, 18, 20, 0, 29, 5, 4, 8,19,13}

0 1 2 3 4 5 6 7 8 9
25 18 20 0 29 5 4 8 19 13

Dizi Kullanıma Örnekler

Örnek: Dizi elemanlarına değer ata, yazdır.

/* 1-10 arsındaki sayıların karesini dizi elemanlarına yükle yazdır */
main()
{
int a[10];
int i;

for (i=0; i<=9; i++)
a[i] = (i+1)*(i+1);

for (i=0; i<=9; i++)
printf("%d . elemanın değeri = %d\n", i, a[i]);
}

Ekranda çıkacak görüntü

0 . elemanın değeri = 1
1 . elemanın değeri = 4
...
9 . elemanın değeri = 100

Örnek : Dizide ilk 20 Fibonacci sayıyı oluştur

/* ilk 20 Fibonacci
f[0] = 0, f[1] = 1, f[i+1] = f[i] + h[i-1] */
#include
main()
{
int fib[20];
int i;

fib[0] = 0;
fib[1] = 1;
for (i=2; i<=19; i++)
fib[i] = fib[i-1] + fib[i-2];

clrscr();
for (i=0; i<=19; i++)
printf("%d . Fibonacci sayısı = %d\n", i, fib[i]);
}

Ekranda çıkacak görüntü
0. Fibonacci sayısı = 0
1. Fibonacci sayısı = 1
2. Fibonacci sayısı = 1
...
19. Fibonacci sayısı = 4181

Örnek : Klavyeden 10 sayı oku. Tersten yazdır.
#include
main()
{
int a[10];
int i;

for (i=0; i<=9; i++) {
printf("%d. sayıyı gir ",i);
scanf("%d", &a[i]);
}

printf("\n-----------------------\n");

for (i=9; i>=0; i–)
printf(“%d . sırada girilen sayı = %d\n”, 9-i, a[i]);
}

Diziyi Bir İşleve Gönderme

Şu ana kadar öğrenilen bilgi çerçevesinde işlevlere gönderilen parametrelerin içeriklerinin işlev içerisinde değiştirilmesi mümkün değildir. İşleve değişkenin değeri gönderilir. İşlev içerisindeki işlemlerden parametre etkilenmez.

Dizilerde durum böyle değildir. Normal kullanımda (şu ana kadar görülen) dizi işleve gönderildiğinde elemanlar değiştirilebilir (referans). Dizinin sadece herhangi bir elemanı gönderildiğinde ise değeri değiştirilemez (değer)

Diziyi işleve gönderirken sadece adını parametre olarak yazmak yeterlidir.

Örnek: işlev içerisnde dizi eleman değerlerinin değiştirilmesi
#include
void kareleri(int []);
main()
{
int a[10];
int i;

for (i=0; i<=9; i++)
a[i] = i + 1 ;

clrscr();
printf("Dizinin elemanlarının değerleri\n");
for (i=0; i<=9; i++)
printf("%d ",a[i]);

kareleri(a);

printf("\n\nKare alma işlemi sonrası dizinin elemanlarının değerleri\n");

for (i=0; i<=9; i++)
printf("%d ",a[i]);
}

void kareleri(int a[])
{
int i;

for (i=0; i<=9; i++)
a[i] = a[i] * a[i];
}

Ekranda çıkacak görüntü
Dizinin elemanlarının değerleri
1 2 3 .. 10

Kare alma işlemi sonrası dizinin elemanlarının değerleri
1 4 9 .. 100
Notlar

* Tanımlanan dizi boyutunun dışında bir eleman kullanımı durumunda C dili hata vermez (uyarmaz).
* İlk indisin değerinin sıfır olması dolayısıyla dizinin n. elemanın indisi n değil n-1 dir.
* Gerektiği durumlarda dizi elemanlarının ilklendirilmesi (sıfırlamak) unutulmamalı
- tanımlama anında int a[10] = {13, 45 ..}; /* fazla eleman yazılırsa hata oluşur */
int a[] = { 13, 45, 56}; /* boyut belirtilen değer kadar olur */
- giriş yaptırarak scanf("%d", &a[i]);
- doğrudan değer atayarak a[i] = 4;

Dizinin Boyutunu Değişken Kılma

#define önişlemcisi direktifi (preprocessor directive)

Simgesel sabit tanımlanmasını sağlar. C dili deyimlerinden biri değildir (#include gibi). Kullanım biçimi

#define SabitAdı Değeri

Program çalıştırıldığınde derleme işlemi öncesinde program içerisinde SabitAdı simgesinim geçtiği yerlere Değeri konur.

Örnek : 25 kişilik bir sınıftaki öğrencilerin sınav sonuçlarını okuyup ortalamasını bulan program.
* not bilgilerin saklanacağı veri yapısını belirle ve tipi tanımla
* notları girdiren yöntemi yaz
* Ortalamayı bulan fonksiyonu yaz

#include
#define OGR_SAY 25

void giris(int []);
float ortalama(int []);
main()
{
int ogr[OGR_SAY];

clrscr();

giris(ogr);

printf(“Ortalama = %f\n”, ortalama(ogr));
}

void giris(int ogr[])
{
int i;

for (i=0; i {
printf("%d. öğrencinin notunu gir : ",i+1);
scanf("%d", &ogr[i]);
}
}
float ortalama(int ogr[])
{
float x;
int i;

x = 0;
for (i=0; i x = x + ogr[i];
return x / OGR_SAY;
}

* 50'den küçük değerleri yazan işlev
* 50'den küçük değerlerin sayısını veren işlev
* en yüksek notu veren işlev
* Standart sapmayı veren işlen ( (abs(Xi - Xort) / OGR_SAY))

Örnek : İki dizinin toplamını üçüncü bir diziye yazan programı yazınız (A, B aynı tip dizi, C = A + B ).
Doğrudan C := A + B yazılamayacağı için dizinin ilgili elemanlarını tek tek toplamalıyız.

#include
#define MAX 20
void dizitopla(int [], int [], int []);
main()
{

int a[MAX], b[MAX], c[MAX];
int i;

for (i=0; i a[i] = i;
b[i] = 2 * i;
}

dizitopla(a, b, c);

clrscr();
for (i=0; i printf(" %4d + %4d = %4d \n", a[i], b[i], c[i]);
}

void dizitopla(int a[], int b[], int c[])
/* c = a +b */
{
int i;

for (i=0; i c[i] = a[i] + b[i];
}

5.3 Sıralama
Dizi elemanlarının küçükten büyüğe veya büyükten küçüğe doğru dizilmesi işlemi. Farklı performansa sahip birçok yöntem vardır. Şimdilik en basit olanlardan biri incelenecektir.

Selection Sort (seçim)

Dizinin en küçük elemanı bulunur ve birinci eleman ile yer değiştirilir. Bu işlem (n-1). elemana kadar tekrar edilir. Her adımda en küçük eleman dizinin kalan elemanlarından bulunur. Örneğin aşağıda 4 elemanlı bir diziye yöntemin uygulanması gösterilmiştir.

Buble Sort

Bu yöntemde ardışıl iki eleman karşılaştırılır. Eğer önceki eleman sonrakinden büyük ise elemanlar yer değiştirilir. Bu şekilde dizi taranır. Eğer herhangi bir değişiklik yapılmış ise işlem tekrar edilir.

Başlangıç 1. adım 2. adım 3. adım
34 21 18 18
21 18 21 21
18 25 25 25
25 34 34 34

Görüldüğü gibi, bu yöntemde dizi sıralandıktan sonra bir defa daha taranıyor.

Selection Sort Kodlaması

1. Dizinin en küçük elemanının indisini veren işlev
2. Bu işlevi kullanarak diziyi sıralama

Bubble Sort Kodlaması

5.4 Çok Boyutlu Diziler

Çok boyutlu bilgileri veya veri tablolarını saklamak için kullanılır. İki boyutlu diziler daha sık kullanılır. Örneğin; yıllara ve aylara enflasyon rakamının takibi, matematikteki matriş işlemlerinin gerçeklenmesi, öğrenciler ve aldıkları derslerin takibi.

Tanımlama biçimi : İki türlü yapılabilir.

Tip Değişken_Adı[ indis1 ][ indis2 ][ indisn ];

Örneğin ;

float Enf[5][12];

Enf tipi iki boyutlu bir dizidir. Birinci boyut ( satır ) yılları, ikinci boyut ( sütun ) ayları gösterir.

1.Ay 2.Ay 3.Ay 4.Ay 5.Ay 6.Ay 7.Ay 8.Ay 9.Ay 10.Ay 11.Ay 12.Ay
1
2
3
4
5

C dilinde boyut sayısında bir sınır yoktur. Biligisayarın belleği boyutu sınırlar.

Dizilerin bellekte saklanma biçimi :
Erişimin kolay olması için dizinin tüm elemanları peşpeşe saklanır. Burada önce satır sonra sütunlar (tanımlanış sırasına göre) saklanır .

!!! Çok boyutlu dizileri bir işleve gönderirken ilk boyut dışındaki boyutların büyüklüklerini vermek zorunludur.

Örnek : İki boyutlu dizi üzerine.

#include

#define SATIR 5
#define SUTUN 5

double enbuyuk(double [][SUTUN], int );
void matris_oku(double [][SUTUN]);

main()
{
double a[SATIR][SUTUN];
double b[SATIR]; /* satirlardaki en buyuk elemanlar */
double c[SATIR]; /* satirlardaki sutunlarin toplami */
int i, j;

matris_oku(a);

for (i = 0; i < SATIR; i++)
b[i] = enbuyuk(a,i);

/* Satirdaki elemanlarin toplamlarinin olusturdugu matris */
for (i = 0; i < SATIR; i++)
{
c[i] = 0;
for (j = 0; j < SUTUN; j++)
c[i] = c[i] + a[i][j];
}

clrscr();

for (i = 0; i < SATIR; i++) {
for (j=0; j printf("%3.0f ", a[i][j]); /* Biçimli yazdırma */

printf(" %4.0f %4.0f\n",b[i],c[i]);
}

}

double enbuyuk(double a[][SUTUN], int sat)
{
double r;
int i;

r = a[sat][0]; /* ilk eleman en buyuk */
for (i = 1; i < SUTUN; i++)
if (a[sat][i] > r)
r = a[sat][i];
return r;
} /* Function EnBuyuk */

void matris_oku(double a[][SUTUN])
{
int i, j;

for (i = 0; i < SATIR; i++)
for (j = 0; j < SUTUN; j++)
a[i][j] = random(10);
} /* matris_oku */

Örnek : Bir kare matrisin

o. Matrisin simetrik olup olmamasını sınayan program
o. Matrisin transpozesini bir diğer matrise kopyalayan program
o. İki matrisinin çarpımını gerçekleştiren program
o. köşegeninin alt kısmındaki elemanları sıfırlayan yöntemi,
o. Determinantını hesaplayan fonksiyonu,
o. M<=P ve N<=Q olmak üzere A matrisi MxN ve B matrisi PxQ boyutlarındadır. B matrisi içerisinde A matrisininin olup olmadığı belirlenecektir. A matrisinin B matrisi içerisinde kaç kez bulunduğunu ve bunların B matrisi içerisinde başlangıç konumlarını (satır ve sütun olarak) veren programı yazınız.
o. MxN elemanlı bir matrisi tek boyutlu bir diziye dönüştüren program
o. P elemanlı bir diziyi MxN boyutlu matrise dönüştüren program (P sayısı M ve N e tam bölünür).

/* Program Matris-2 */

#include

#define SATIR 3
#define SUTUN 3

void matris_oku(int [][SUTUN]);
void matris_yaz(int [][SUTUN]);
int simetrik(int [][SUTUN]); /* matrisin simetrikliğini sınar */
void transpoze(int [][SUTUN], int [][SUTUN]); /* 2. = 1.nin transpozesi */
void matris_carp(int [][SUTUN], int [][SUTUN], int [][SUTUN]); /* 3 = 1*2 */
/*
alt_ucgen_sifirla(a);

matris_yaz(a);
printf(“————————\n”);

transpoze(a, b);

matris_yaz(b);

matris_carp(a, b, c);

printf(“————————\n”);

matris_yaz(c);

if (simetrik(a))
printf(“Simetriktir\n”);
else
printf(“Simetrik değildir\n”);

*/

getch();

}

void matris_oku(int a[][SUTUN])
{
int i, j;

for (i = 0; i < SATIR; i++)
for (j = 0; j < SUTUN; j++)
a[i][j] = 1 + random(5);
} /* matris_oku */

void matris_yaz(int mat[][SUTUN])
{
int i, j;

for (i = 0; i for (j = 0; j printf("%3d ",mat[i][j]);
printf("\n");
}
}
int simetrik(int a[][SUTUN])
{
int i,j;
int durum;

durum = 1; /*simetrik olduğunu varsay */

for (i = 0; i for (j = 0; j if (a[i][j] != a[j][i]) {
durum = 0;
break;
}

return durum;
} /* simetrik */

void transpoze(int a[][SUTUN], int b[][SUTUN])
{
int i, j;

for (i = 0; i for (j = 0; j b[i][j] = a[j][i];
}

void matris_carp(int a[][SUTUN], int b[][SUTUN], int c[][SUTUN])
/* c = a * b */
{
int i, j, k;

for (i = 0; i for (j = 0; j c[i][j] = 0;
for (k=0; k c[i][j] = c[i][j] + a[i][k]*b[k][j];
}

}

void alt_ucgen_sifirla(int a[][SUTUN])
{
int i,j;

for (i = 0; i for (j = 0; j a[i][j] = 0;

}

int det(int a[][SUTUN])
{
int i, j, k;
int s, sx1, sx2;

s = 0;

/*
for (j = 0; j sx1 = 1;
sx2 = 1;
for (k = 0; k i = (j + k) % SUTUN;
sx1 = sx1 * a[k][i];
sx2 = sx2 * a[k][SATIR-k];
}
s = s + sx1 - sx2;
}

*/
return s;
}

6. Karakter işleme

Birçok program sayıların yanı sıra metinler üzerine işlem yapar. İlk akla gelen bir kelime işlem programıdır. Bu tür bir programda metinlerle ilgili olarak, araya karakter girme, silme, değiştirme ve arama gibi işlemler tanımlıdır. C dilindeki char tipi bu tür verilerin saklanması için kullanılır.

6.1 Tanımlamalar ve Kullanım

karakter: Bilgisayarda tanımlı herhangi bir karakteri gösterir. Karakter sabitler tek tırnak içinde belirtilir.
'A', '0'
'\65' : \ işaretinin ardından belirtilen ASCII kodlu karakter
C dili karakterleri ayrıca int değer gibi de görür. 'A' karakteri sayısal olarak A harfinin ASCII tablosundaki karşılığı olan 65 olarakta yorumlanabilir.

dizgi (string): Bir dizi karakterden oluşur. '\0' karakteri dizginin sonunu gösterir.Dizgi sabitler çift tırnak içinde gösterilir.
"ALİ", "Bir sayı girin"

Bu idafede dil \0 karakterini otomatik koyar.

Karakter ile dizgi birbirinden farklı şeylerdir. Dizginin sonunda herzaman \0 karakteri vardır.
'A' ile "A" birbirinin aynısı değildir. 'A' karakterini gösteren 65 değerinde bellekte int olarak salanırken "A" ise bir dizgi olup A ve \0 karakterlerini içerir.

Tanımlama biçimi:

1. Dizi şeklinde tanımlama

char a[7] = {'K','O',,'C','A','E','L','İ'};
char a[8] = "KOCAELİ"; /* Son eleman olrak \0 karakteri eklendiği için eleman sayısını bir fazla belirtmeli */ 2. İşaretçi olarak tanımlama

char *değişken;

char *a;

Doğrudan Değer Atama

char a[20];
char *b;

a[0] = 'A'; /* dizinin bir elemanına değer verir gibi ve tek tırnak içinde ( karakter sabiti) */
\0 karakteri ayrıca belirtilmelidir.

Dizi biçiminde tanımlı dizgiye sabir bir dizgi atarma için strcpy işlevi kullanılır.

strcpy(char *hedef, const char *kaynak); kaynak bilgisini hedef değişkenine kopyalar (string.h)
Hedef dizgisinde kaynak dizgisini içerecek kadar yer olmalıdır.
strcpy(a, "ALİ");

b = "ALİ"; /* çift tırnak içinde atanacak değer . \0 karakteri otomatik eklenir */

Değerini Yazdırma

printf("%s", a);
puts(a); sonu \0 ile biten karakter dizisini ekrana yazar ve imleçi alt satıra geçirir ( stdio.h )

Klavyeden Değer Atama

scanf("%s", a); /* Boşluk karakterine kadar okuma yapacağı için içerisinde bu karakterin geçmesi olası girişlerde doğru çalışmaz. Adres operatörü kullanılmıyor */

gets(a) ; Satır sonu karakterine kadar (ENTER tuşu) basılan karakterleri okur ( stdio.h )

Karakter Dizisinin Herhangi Bir Karakterine Erişme

Dizilerde olduğu gibi erişilmek istenen karakterin indisi bildirilir.

a[2] = 'G'; b[2] = 'G';
a[4] = '\0';
printf("%c ", b[3]); /* b'nin 4. elemanını yazar */

Örnek 6.1.1 : Girilen bir metnin uzunluğunu veren programı yazınız.

#include
main()
{
char *s;
int i;
gets(s);
i = 0; for (i=0; s[i]!=’\0′; i++)
while (s[i]!=’\0′) {} /* boş işlem */
i++;

printf(“Uzunluk %d \n”, i);
}

strlen ( char *) : Gönderilen değerin uzunluğunu verir. (string.h)

Örnek 6.1.2: Girilen bir metni tersten yazdıran programı yazınız.

#include
#include
main()
{
char *s;
int i;
gets(s);
for (i=strlen(s)-1; i>=0; i–)
printf(“%c”, s[i]);
printf(“\n”);
}

Örnek 6.1.3 : Girilen cümleyi oluşturan kelimelerin sadece ilk harflerini yazdıran program.
1. c = sıradaki karakteri oku
2. Eğer c boşluk ise 4. adıma git
3. Hiç karakter yazılmaış ise c’yi yaz.
4. Eğer son karakter ise dur aksi halde bir sonraki karakteri göster ve 1.adıma git.
Yukarıdaki algoritmada çözümün en önemli noktası herhangi bir kelimenin ilk karakterinin yazılıp yazılmadığıdır. Bunun izlenmesi için bir değişken kullanalım.

/* Girilen cümlenin ilk harflerini yaz */
main()
{
int i;
int yaz; /* 1/0 -> karakteri yaz/yazma */
char *s;

clrscr();
gets(s);
yaz = 1;
for (i = 0; i if (s[i] == ' ')
yaz = 1;
else
if (yaz) {
printf("%c", s[i]);
yaz = 0;
}
}

Örnek 6.1.4: Girilen cümleyi, kelimeleri bozmadan tersten yazdıran program.
Ali zil çaldı --> çaldı zil Ali

İki Dizginin Karşılaştırılması

C dilinde diziler doğrudan karşılaştırılamazlar. Her bir elemanını ayrı ayrı karşılaştırılmalıdır. Küçüklük-büyüklük bilgisi ASCII tabloda önce-sonra bulunma bilgisine özdeştir. Karşılaştırma amacıyla strcmp(dizgi1, dizgi2)
işlevi kullanılır. İşlev üç değer alır.
<0 ise dizgi1 < dizgi2
=0 ise dizgi1 = dizgi2
>0 ise dizgi1 > dizgi2

Örnek 6.1.5:
int main()
{ char *s1 = “aaa”, *s2 = “aba;
int i;
i = strcmp(s1, s2);
if (i > 0)
printf(“s1 büyük \n”);
else if (i<0)
printf("s2 büyük\n");
else
printf("eşitler\n");
}
İki Dizgiyi Toplama (ekleme)

Dizgiler ile ilgili diğer sık kullanılan işlev strcat(hedef, kaynak) tir. kaynak dizgisini hedeh dizgisine ekler.
Hedef dizgisinde kaynak dizgisini içerecek kadar yer olmalıdır.

int main()
{
char *s1 = "aaa ", *s2 = "bbb";
int i;
strcat(s1, s2); /* (string.h) */
printf("%s\n", s1);
}

6.2 atoi , atof, atol .. İşlevlerini Gerçekleme

Genellikle bir programın akışı boyunca bazı verilerin tiplerinin değiştirilmesi gerekir. Bu değişim string tipindeki bir değişkenin sayısal tipe dönüştürülmesi veya tersi biçiminde olabilir. Sayısal string : içeriği C'nin sayı gösterimine uygun olan metin. '5.87' , '0.3E5' , '3423'

Örnek 6.2.1: String tipi bir değişkenin değerini tamsayısal tipe dönüştüren işlevi yazınız.(atoi (stdlib.h))
Girdi : Tamsayısal string
Çıktı : Karşılık gelen sayı

#include
#include
int deger (char *);
main()
{
char *c;
int i;

c=”93t54″;
i=deger(c);
printf(“%s dizi katarının sayısal karşılığı %d \n”,c, i);
}
int deger( char *s)
{
int i,j;
int x; /*sayı */
x = 0;
for (i = 0; i j = s[i] - '0';
x = x * 10 + j ;
}
return x; }

Örnek 6.2.2 : Önceki örnekteki değer işlevini ondalık sayıları da (nokta dikkate alınacak) işleyecek şekilde geliştiriniz.

Yukarıda yazmaya çalıştığımız işlevin C dilinde karşılığı mevcuttur (stdlib.h).
int atoi(char *s) : tamsayıya dönüştürür.
long int atol(char *s) : uzun tamsayıya dönüştürür.
double atof(char *s) : gerçel sayıya dönüştürür.
Bu işlevler dönüştürme işlemine s içerisinde geçersiz bir karakter ile karşılaşıldığında son verir. Ve bu noktaya
kadar karakterlerin oluşturduğu sayıyı verir. İlk karakter geçersiz ise işlevin değeri tanımsızdır. Aynı işlevlerin biraz daha gelişmişleri ise;

double strtod(const char *s, char **ss) :
long int strtol(const char *s, char **ss, int base) :
unsigned int strtol(const char *s, char **ss, int base) :

s : string bilgi
ss : s değişkeninde ilk geçersiz karakter ve sonrasında katar dizini gösterir
base : dönüşümün hangi tabana göre yapılacağını belirtir.

Örnek 6.2.3: atoi, atol, atof işlevlerinin davranışları.
main()
{
char *s;
int i;
long x;
double f;

s="5";
printf("%d %ld %f\n",atoi(s),atol(s),atof(s));
s="5.4";
printf("%d %ld %f\n",atoi(s),atol(s),atof(s));
s="5.2e4=KL";
printf("%d %ld %f\n",atoi(s),atol(s),atof(s));
}
s değeri çıktı
--------------------------------------------------
5 5 5 5.000000
5 5 5 5.400000
5 5 5 52000.000000

Giriş İşlevleri

main()
{
char c1, c2;
char s[10];
clrscr();
c1 = getchar(); /* klavyeden ENTER tuşuna basılana kadar tuş bekler */
/* cursor on, karakter yazılır */
c2 = getchar(); /* klavyenin tamponundaki sıradakini okur */
printf("\n%c , %c\n",c1,c2);
c1 = getche(); /* tuş basılmasını bekler, ENTER beklenmez*/
/* cursor on, karakter yazılır */
c2 = getche(); /* tuş basıldıktan sonra kontrol bu satıra geçer */
printf("\n%c , %c\n",c1,c2);
c1 = getch(); /* tuş basılmasını bekler, ENTER beklenmez */
/* cursor on, karakter yazılmaz x int putch(int c): c ekrana yazılır*/
c2 = getch(); /* tuş basıldıktan sonra kontrol bu satıra geçer */
printf("\n%c , %c\n",c1,c2);
}

Örnek 6.2.4: Tamsayı bir değeri dizgiye dönüştüren programı yazınız. (ecvt, fcvt, gcvt var ancak ANSI C değil)
#include

int main()
{
char *s;
int i;
i = 2137;
itostr(s, i);
printf(“%d %s\n”,i, s);
}
itostr(char *hedef, int sayi)
{
int i, j, kb;
j = sayi;
for (kb = 0; j>0; kb++)
j = j / 10;
i = sayi;
for (j=kb-1; j>=0; j–) {
hedef[j] = ’0′ + i % 10;
i = i / 10;
}
hedef[kb] = ‘\0′;
}

sprintf işlevi : sayısal değeri dizgiye dönüştürmek için kullanılabilir. Yapısı;

sprintf( dizgi, kontrol, değişkenler)

Kullanım şekli printf işlevine yakındır. Kontrol ve değişken bilgisine göre ekrana yazılması gereken bilgi parametre olarak gönderilen dizgiye kopyalanır.

char *s;
int i = 57;
sprintf(s, “%d”, i);

ifadesi sonunda s dizgisinde “57″ değeri oluşur.

float f = 2.1;
sprintf(s, “%f”, f);

ifadesi sonunda s dizgisinde “2.100000″ değeri oluşur.

Örnek 6.2.5: Bir dizginin belirli bir parçasını veren işlev. (strncpy(s2, s1, n))
#include
int main()
{
char *s1;
char *s2;
s1 = “01234567890″;
altdizgi(s2, s1, 0, 5);
printf(“%s\n”,s2);
}
void altdizgi(char *hedef, char *kaynak, int bas, int uzunluk)
{
int i;
for(i = 0; i < uzunluk && kaynak[bas + i] != '\0'; i++)
hedef[i] = kaynak[i + bas];
hedef[i] = '\0';
}

Örnek 6.2.6: Bir metin içerisinde bir metin parçasın bulma (konumunu belirleme).
Girdi : . aranacak metin parçası (String) , aramanın yapılacağı metin (String)
Çıktı : aranan bilgi var ise başlangıç konumu (Integer) =-1 ise yok demektir
main()
{
char *a="12345";
char *b="34";
printf("%s %s\n",a, b);
printf("%d\n",kon(a, b));
}

int kon(char *s1, char *s2)
{
int i = 0, j, konum = -1;
while (i < strlen(s1) - strlen(s2))
{
konum = i;
for (j = 0; j < strlen(s2); j++)
if (s1[i + j] != s2[j])
konum = -1;
if (konum >= 0)
break;
else i = i + 1;
}
return konum;
}
C dilinde benzer bir işlevi sağlayan deyim

char *strstr(const char *dizgi1, const char *dizgi2)

dizgi1 içerisinde dizgi2 yi arar. Var ise işlev dizgi1 içerisinde dizgi2 nin başladığı konumdan sonraki dizgiyi işaret eder. Yok ise işlevin değeri NULL dır.

NULL : işaretçinin herhangi bir yeri göstermemesi. Değerinin boş olması.

Örnek 6.2.7: Bir dizgi içerisindeki bir karakterin bulunması. i harfini İ ile değiştiren program.
#include
#include
int main()
{
char *s1, *s2, *s3;
int i;
clrscr();
s1=”ali zil çaldi”;
strcpy(s2, s1);
for (i=0; i if (s1[i] == 'i')
s1[i] = 'İ';
printf("%s\n",s1);

char *strchr(char *s, char c) : s dizgisi içerisinde c karakterinin konumunu gösteren dizgiyi gönderir.

while (strchr(s2, 'i') !=NULL) {
s3 = strchr(s2, 'i');
s3[0] = 'İ';
}
printf("%s\n",s2);
}

Örnek 6.2.8: Bir cümledeki tüm küçük harfleri büyüye çeviren program.
(int tolower(int c) , int toupper(int c) ) (ctype.h)

#include
#include

void buyuk(char *);
int main()
{
char *s1, *s2, *s3;
int i;
clrscr();
s1=”ali zil çaldi”;
strcpy(s2, s1);
for (i=0; i printf("%c",toupper(s1[i]));

buyuk(s2);
printf("\n%s",s2);
getch();
}
void buyuk(char *s)
{
int i;
for (i=0; i s[i] = toupper(s[i]);
}

Örnek 6.2.9: Girilen metindeki harflerin sıklığını (frekansını) hesaplar.
#include main() { char *s; char *harfler = “abcdefghijklmnopqrstuvwxyz”; char c; int fr[26] = {0,}; int i; clrscr(); gets(s); for (i = 0 ; i

7. Diğer Veri Tipleri

Standart C dilinde şu ana kadar öğrendiğimiz veri tiplerine ek olarak aşağıdaki tipler mevcuttur.

7.1 C de Tanımlı Veri Tipleri

Veri Tipleri

Tip Aralık Uzunluk(Byte)
unsigned char char enum unsigned int short int int unsigned long long float double long double 0 .. 255 -128 .. 127 -32,768 .. 32,767 0 .. 65,535 -32,768 .. 32,767 -32,768 .. 32,767 0 .. 4,294,967,295 -2,147,483,648 .. 2,147,483,647 3.4 * (10**-38) .. 3.4 * (10**+38) 1.7 * (10**-308) .. 1.7 * (10**+308) 3.4 * (10**-4932) .. 1.1 * (10**+4932) 1 1 2 2 2 2 4 4 4 8 10

printf işlevinde dönüşüm karakteriden önce

h short
u unsigned
l long integer
L long double

u dönüşüm karakteri unsigned

7.2 Kullanıcı Tanımlı Veri Tipleri

Enumerated (Sıralı, Numaralandırılmış) Tipler

Programın okunabilirliğini arttırmak için değerlerin sıralı bir küme olarak tanımlanması.

enum [tip_adi] { sabit adı [= değer],...} [değişken listesi];

değer : sabite otomatik atanan değer. Belirtilmez ise 0'dan başlar. Sıradaki sabit öncesinin bir fazlasına eşittir.

Belirtilen tipte tanımlı bir değişken ancak listedeki değerleri alır.

enum renk {BEYAZ, SARI, SIYAH};

tanımlaması ile oluşan enum renk tipinde BEYAZ 0, SARI 1 ve SIYAH 2 değerlerine eşit sabitlerdir.
Listedeki sabitler belirkeyici olmalıdır. Sayısal, karakter ve string bilgi yazılamaz.
enum renk = {"Beyaz", "Sari"}; X
enum renk = {0, 1, 2}; X

. İlişkisel işleçler tanımlıdır. Beyaz < Siyah, Sari > Beyaz

Bu tip değişkenler switch ve for deyimlerinde kontrol değişkeni olarak kullanılabilir.

Bu tipte bir değişken bilinen yapıda tanımlanır.

enum renk {BEYAZ, SARI, SIYAH};
enum renk a;

a değişkeni BEYAZ, SARI ve SIYAH değerlerinden birini alabilir.

Örnek 7.2.1: enum kullanımı.
main()
{

enum gunler {PAZAR,PAZARTESI,SALI,CARSAMBA,PERSEMBE,CUMA,CUMARTESI };
enum gunler gun;

clrscr();

for (gun = PAZAR; gun <= CUMARTESI; gun++)
printf("%d ", gun);
printf("\n");

for (gun = PAZAR; gun <= CUMARTESI; gun++)
switch (gun) {
case PAZAR: printf("Pazar"); break;
case PAZARTESI: printf("Pazartesi"); break;
case SALI: printf("Sali"); break;
case CARSAMBA: printf("Carsamba"); break;
case PERSEMBE: printf("Persembe"); break;
case CUMA: printf("Cuma"); break;
case CUMARTESI: printf("Cumartesi"); break;
} /* Case */
}

Örnek 7.2.2: enum kullanımı.

main()
{
enum gunler {PAZAR,PAZARTESI,SALI,CARSAMBA,PERSEMBE,CUMA,CUMARTESI };
enum gunler gun;
char *gunad[]={"Pazar","Pazartesi","Sali","Carsamba",
"Persembe","Cuma","Cumartesi"};
clrscr();
for (gun = PAZAR; gun <= CUMARTESI; gun++)
printf("%s\n", gunad[gun]);
}

Örnek 7.2.3: Sabitlere farkli değerler atama

enum renkler { sari = 4, mavi, kirmizi };
enum renkler i;
main()
{
i = mavi;
printf("%d \n", i);
}

Ekrana 5 yazar.

Problem : Bu tip değişkenler doğrudan okunup yazılamazlar.

* Okumak ise yazmaya oranla biraz daha zordur. Okuma işlemi diğer standart tipler kullanılarak dolaylı bir şekilde gerçekleştirilir.

8- Yapılar (struct)

Farklı tipte birden fazla verinin oluşturduğu bütün.

Veri tipi olarak daha önce diziyi tanımlamıştık. Dizide birbirinin aynı tipi olan veriler peşpeşe saklanıyordu.
Yapılar da aynı dizi gibi birbirleriyle ilgili olan verileri içerir. Fakat diziden farkı, tek bir yapı elemanı birbirnden farklı tipte birden fazla veriyi içerir. Bu sayede bilgiler daha düzenli şekilde gösterilir.
Yapı yeni bir tip olmayıp var olan standart tiplerden oluşur.

8.1 Yapı Tanımı

Bir öğrencinin numarasını, adını ve sınavdan aldığı notu içeren bir yapı tanımlaması aşağıdaki gibidir.

struct ogryapi {
char numarasi[10];
char adi[20];
int notu ;
}

struct ogryapi ogr;

Artık ogryapi isimli bir veri tipi vardır ve üç üyeden (alandan) oluşmaktadır ( member =üye : kayıdı oluşturan farklı veri tiplerinin her biri).
* Tanımlamada her alanın adı ve tipi belirtilir.
* Yapı tipi olduğunu gösterir struct saklı sözcüğü kullanılır.
* Aynı alan adı farklı yapılarda (bağımsız olarak) kullanılabilir.

Tanımlama genel olarak

struct Yapı_Adı {
Alan1;
Alan2;
. . .
Alan_n;
};
Bu tipte bir değişken ise
struct Yapı_Adı Deği_Adı;
şeklinde yapılır.

Tanımlanan tipte bir değişken tanımlandığınıda, değişken için bellekte tüm alanları içerecek şekilde yer ayırılır.
İlgili değişkendeki herhangi bir alan üzerinde işlem yapmak için aralarında nokta karakteri olmak koşuluyla sırasıyla değişkenin adı ve ilgili alanın adı verilir. Yukarıdaki öğrenci örneğinde öğrecinin numarasına
ogr.numarasi şeklinde erişilir.

Örnek 8.1.1: Karmaşık sayılarda toplama işlemi gerçekleştirme.
main()
{
struct complex {
float real, imag;
};
struct complex z1, z2, z3;

clrscr();
printf("1. sayının reel ve imajiner kısımları gir ");
scanf("%f %f", &z1.real, &z1.imag);
printf("2. sayının reel ve imajiner kısımları gir ");
scanf("%f %f", &z2.real, &z2.imag);

z3.real = z1.real + z2.real;
z3.imag = z1.imag + z2.imag;
printf("%2.0f + %2.0fj\n",z3.real, z3.imag);
}

Örnek 8.1.2: Yapı içerisinde başka bir yapı kullanımı.

struct tarih {
int gun;
int ay;
int yil;
};
struct kisiler {
char adi[21];
struct tarih dogum;
};
main()
{
struct kisiler a;
strcpy(a.adi,"veli");
a.dogum.gun = 15;
a.dogum.ay = 8;
a.dogum.yil = 1905;

printf("%s %d\n",a.adi,a.dogum.yil);
getch();
}

Diğer bir tanımlama şekli

struct {
Alan1;
Alan2;
. . .
Alan_n;
} değişkenler;

struct {
float real, imag;
}z1, z2, z3;

Örnek 8.1.3: Öğrenci ile ilgili olarak numara ve sınav notu oku. Sınavın ortalamasını ve ortalamayı geçenleri listele

#define OGRSAY 3
main()
{
struct ogrenci{
char no[10];
int notu;
};

struct ogrenci ogr[OGRSAY];
int i, j;
float t, ort;

clrscr();

for (i=0; i printf("%d. öğrencinin numarası ve notu : ", i+1);
scanf("%s%d",ogr[i].no, &ogr[i].notu);
}

t = 0;
for (i=0; i t = t + ogr[i].notu;

ort = t / OGRSAY;
printf("--------------------------------------------\n");
printf("Ortalama = %f\n", ort);
printf("--------------------------------------------\n");
printf("Ortalamayı geçen öğrenciler\n");
for (i=0; i if (ogr[i].notu > ort)
printf(“%s\t\t%d\n”, ogr[i].no, ogr[i].notu);

getch();
}

Tanımlama Anında Yapı Değişkenine Değer Atama

struct ogryapi a = {“95003″, 56};

Veri Tiplerine Yeni İsim Verme

C dilinde var olan veri tiplerini yeni bir isim vermekmümkündür. Tanımlama biçimi:

typedef tanımlı_tip yeni_ismi;

typedef int tamsayi;

Artık tamsayı isminde bir veri tipi vardır. Değişken tanımlamada kullanılabilir.

tamsayi i, j;

typedef unsigned char byte;
byte x;

Yapılar ile kullanımı

struct complexyapi {
float re, im;
};
tydef struct complexyapi complex;
complex z1, z2;

veya

typedef struct { float re, im } complex;
complex z;

Örnek 8.1.4: İşlevin değerinin yapı olması durumu

typedef struct {
float re, im;
} complex;

main()
{
complex topla(complex, complex);
complex cikart(complex, complex);
complex carp(complex, complex);

complex z1={1,1}, z2={2,2};
complex z3;

clrscr();
printf(“%3.0f %3.0fj %3.0f %3.0fj\n”,z1.re,z1.im,z2.re,z2.im);

z3 = topla(z1, z2);
printf(“%3.0f %3.0f\n”,z3.re,z3.im);

z3 = cikart(z1, z2);
printf(“%3.0f %3.0f\n”,z3.re,z3.im);

z3 = carp(z1, z2);
printf(“%3.0f %3.0f\n”,z3.re,z3.im);
getch();
}
complex topla(complex a, complex b)
{
complex z;
z.re = a.re + b.re;
z.im = a.im + b.im;
return z;
}
complex cikart(complex a, complex b)
{
complex z;
z.re = a.re – b.re;
z.im = a.im – b.im;
return z;
}
complex carp(complex a, complex b)
{
complex z;
z.re = a.re * b.re – a.im * b.im;
z.im = a.re * b.im + a.im * b.re;
return z;
}

Union: Değişken Yapısı

Bir yapıdaki üyelerin hepsi aynı durumda kullanılmayabilir. Üyelerin bir bölümü belirli bir durum için geçerli iken bir kısmı farklı bir durum için geçerlidir. Gereksiz yer harcamalarına karşı union tipi kullanılabilir.
Tanımlama biçimi:

union ad {
tip değişken_1;
tip değişken_2;
…
tip değişken_n
};

Aynı yerde belirtilen alanlardan herhangi biri saklanır. En uzun alan ne ise o kadar yer ayrılır.

union ikisi {
int kisa;
long uzun;
};
union ikisi i;
main()
{
i.uzun = 32768;
printf(“%d %ld \n”,i.kisa, i.uzun); {-32768 32768 }
}

Union Değişkenin Tanımlama Anında Değer Alması

Değişkene tanımlama anında değer atandığında alanlardan ilki kullanılıyor gibi davranır dil. Bu nedenle atanacak değerin tipine dikkat edilmelidir.

union sayilar {
int i;
float f;
};
union sayilar a = {2}; /* a.i = 2 anlamındadır */

union sayilar a = {2.7}; /* a.i = 2 değeri atanır. */

Bitler Üzerine Çalışmalar

VE , VEYA ve DEĞİL işleçleri mantıksal ifadeleri bağlamakta kullanıldığı gibi doğrudan tamsayılar üzerinde de kullanılabilir. Bu kullanımda işleçler doğrudan tamsayıyı oluşturan bitleri etkiler.

x & y : x ve y tamsayılarının bitlerinin sırayla VE işlemine tutar. (AND)
x | y : x ve y tamsayılarının bitlerinin sırayla VEYA işlemine tutar. (OR)
~ x : x tamsayının her bir bitinin tersini alır (NOT)
x ^ y : x ve y tamsayılarının bitlerinin sırayla dışlayan VEYA işlemine tutar. (exclusive OR)
x << n : x sayısını n bit sola kaydırır. Boşalan yerlere 0 gelir.
x >> n : x sayısını n bit sağa kaydırır. Boşalan yerlere 0 gelir.

x y & | ^
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0

5 & 3 = 1
(101) & (011) = (001)
| = (111) yani 7
5 << 1 = 10 --> (101) shl 1 = (1010)

Hex-Octal gösterim
0xn : n 16 lıdır (HEXADECIMAL) 0×11 : 17
0n : n 8 lidir (OCTAL) 011 : 9
n : n 10 ludur (DECIMAL) 11 : 11

Klavyedeki tuşların durumunu gösterir bilgi bellekten okunduğunda her bitin anlamı şöyledir.
Bit No
0 sağ shift basılı/basılı değil
1 sol shift basılı/basıldı değil
2 kontrol tuşu basılı/basılı değil
3 alt tuşu basılı/basılı değil
4 scroll tuşu açık/kapalı
5 num lock tuşu açık/kapalı
6 caps lock tuşu açık/kapalı

Bu durumda num lock tuşunun açık olup olmadığını anlamak için okunan bilginin 5. bitinin değerini sınamak gerekecektir. Okunan bilginin x olduğunu varsayr ise;

if (x & 32)
printf(“num lock açık”);
else
printf(“num lock kapalı”);

x & 32 işlemine x değerinin 32 sayısı ile maskelenmesi denir. 32 değeri maske diye çağırılır. 32 sayısının 8 bit olduğunu düşünürsel sayının sadece 5. biti bir olup diğerleri sıfırdır.

32 = (0010 0000)

x & 32 işlemi ile x değerinin 5. bitinin bir olup olmaması sınanır. Bir ise sonuç 32 (farklı sıfır), sıfır ise sonuç 0 olur.

Örnek 8.1.5: Klavyedeki Num Lock tuşunun durumunu söyleyen programı yazınız.
#include
main()
{
unsigned int b1;
clrscr();
b1 = peek(0×0040, 0×0017); /* dos.h> */
if (b1 & 32)
printf(“Num lock açık\n”);
else
printf(“Num lock kapalı\n”);
getch();

İlgili işlevler
poke (segment, offset, int value) X peek (segment, offset)
pokeb (segment, offset, char value) X peekb(segment, offset)

Örnek 8.1.6: Öğrencinin doğum tarihi 2 Byte tamsayı olarak saklanmaktadır.
Bu bilginin kodlaması şöyledir.
bit anlamı
0 – 4 gün
5 – 8 ay
9 -15 yıl (+1970)

Böyle bir bilgiyi çözen program.

#include
main()
{
unsigned int i;
clrscr();
scanf(“%d”, &i);

printf(“%2d”, i&0x1f);
i = i >> 5;
printf(“/%2d”, i&0x1f);
i = i >> 4;
printf(“/%4d”, i+1970);

}

Örnek 8.1.7
unsigned swap(unsigned) : gönderilen tamsayının düşük ile yüksek sekizlisinin yerini değiştirilmişini verir
unsigned max(unsigned) : gönderilen tamsayının düşük sekizlisi ile yüksek sekizlisinden büyüğünü verir

main()
{
unsigned i, j;

i = 0xAA11;
clrscr();
printf(“%x %x %x\n”, i, swap(i), max(i));

getch();
}

unsigned swap(unsigned a)
{
return (a>>8) | (a<<8);
}
unsigned max(unsigned a)
{
unsigned lo, hi, m;

lo = a & 0x00FF;
hi = a >> 8;
m = (lo>hi) ? lo:hi;
return m;
}

Örnek 8.1.8: Aşağıdaki işlevlerin gerçekleştirilmesi.

void binary_yaz(unsigned x); { x tamsayısının 2li düzendeki karşılığını yazar }
unsigned copybits(x, b, n) { x sayısının sağdan b. bitinden itibaren n bitini verir}
unsigned ters(x, b, n): { x sayısının sağdan b. bitinden itibaren n bitini tersini alır}
unsigned rdon(x, n): { x sayısını n bit sağa döndürür}

/* Programın başlangıcı */
typedef unsigned int word; /* kolaylık i.in */

void binary_yaz(word);
word copybits(word x, word b, word n);
word ters(word x, word b, word n);
word rdon(word x, word n);
word sdon(word x, word n);

main()
{
word i, j;

clrscr();

for (i=16; i>0; i–)
printf(“%x”, i-1);
printf(“\n”);

i = 0xee;
binary_yaz(i); printf(“\n”);
j = copybits(i, 5, 4); binary_yaz(j); printf(” copybits(i, 5, 4) \n”);

j = ters(i, 5, 4); binary_yaz(j); printf(” ters(i, 5, 4)\n”);

j = rdon(i, 4); binary_yaz(j); printf(” rdon(i, 4)\n”);

getch();

}
word copybits(word x, word b, word n)
/* x sayısının sağdan b. bitinden itibaren n bitini verir. */
/* ilk bitin numarası 0 */
{
word i;

i = x >> (b + 1 – n); /* ilgili bit bloğunun sağa dayalı olacak */
/* biçimde kaydır. */

i = i & ~(~(0) << n); /* sağdaki n bit için maske oluştur */
return i;
} /* End Of copybits */

word ters(word x, word b, word n)
/* x'in b. bitinden itibaren n bitin tersini alır */
{
word p, r;

p = ~(x);
r = ~(~(0) << n) << (b - n + 1); /* seçilen bitler için maske */
p = p & r;

x = x & ~(r);
return x | p;
/*
8 bit için ters(. ,5,4)
76543210
x = 0110 1000
p = 1001 0111
r = 00111100 ~(~(0) << n) << (b - n + 1)
p = 00010100 p = p & r
x = 0100 0000 x & ~(r)
= 01010100 x | p dönen
} /* End of test */

word rdon(word x, word n)
/* x'i n bit sağa döndürür */
{
word i;
for (i = 1; i <= n; i++)
{
if (x % 2 == 1)
{
x = x / 2;
x = x | 0x8000;
}
else
x = x / 2;
}
return x;
} /* End of rdon */

word sdon(word x, word n)
/* x'i n bit sağa kaydırır. RDon fonksiyonun başka biçimi */
{
word i;

i = copybits(x,n - 1,n);
x = x >> n;
i = i << (16 - n + 1);
return x | i;
} /* End of RDon */

void binary_yaz(word x)
{
int i;
word m;

m = 0x8000;
for (i = 0; i<16; i++) {
if (x & m)
printf("1");
else
printf("0");
m = m >> 1;
}
}

9. Pointer (gösterici, işaretçi)

9.1 Tanımlanması ve Kullanımı

Bir veri bloğunun bellekte bulunduğu adresi içeren (gösteren) veri tipidir. Tanımlama biçimi:

veri tipi *p;

p değişkeni ile belirtilen tipte bir verinin bellekte saklandığı adresi içerir.

int *iptr;
float *fptr;

Bu kadar tanımla sonucunda bellekte p değişkeni mevcuttur. Ancak işaret ettiği veri bloğu yoktur. Bunun için iki yol vardır. Birincisi kullanılan herhangi bir değişkeni işaret etmek, ikincisi ise veri bloğunu boş belleği kullanarak oluşturmak.

1. İşaretçi değişkenin var olan bir değişkenin bulunduğu adresi göstermesi.

Bu işlemi yapabilmek için var olan değişkenin adresinin bilinmesi gerekmektedir.

& işleci : Bir değişkenin adresinin belirlenmesi için kullanılır. Kullanım biçimi:

&değişken

&i : i değişkenin adresini verir.

main()
{
int i;
int *iptr;
i = 5;
iptr = &i;
clrscr();
printf(“i değişkeninin adresi %p\n”, &i);
printf(“iptr değişkeninin değeri %p\n”, iptr);
}

Bellek modeline göre SSSS:OOOO veya OOOO biçiminde adres yazar.

8FF8:1000

2. Veri bloğunu boş belleği kullanarak oluşturmak.

Bu yolla veriler için dinamik yer ayırılır. Bunun için malloc işlevi kullanılır
void *malloc(n) : Boş bellekten n byte yer ayırıp başlangıç adresini döndürür.
iptr = (*int) malloc(2);
!!!!!!!!! Daha sonra dönüş yapılacak. sizeof, cast işleci (*tip) …

Veriye işaretçi değişken yoluyla erişim

Bir işaretçinin gösterdiği adresteki veriye erişmek için işaretçi değişkeninin önüne * karakteri konur.
main()
{
int i;
int *iptr;
iptr = &i;
*iptr = 8;
printf(“i değişkeninin değeri %d\n”, i);
printf(“iptr adresinin içeriği %d\n”, *iptr);

}

Ekranda çıktı :
i değişkeninin değeri 8
iptr adresinin içeriği 8

!!! İşaretçi değişkenin gösterdiği adresin içeriği değişken ilklendirmeden kullanılmamalıdır

9.2 İşaretçi Aritmetiği

İşaretçi değişkenler üzerinde toplama ve çıkartma işlemleri (++, –) geçerlidir. Ancak eklenecek değer tamsayı olmalıdır.
İşaretçi değişkenin değeri 1 arttırıldığı zaman değişken bir sonraki veri bloğunu işsaret eder. Değişkenin alacağı yeni değer işaretçi değişkenin ne tip bir veri bloğunu işaret ettiğine bağlıdır.

int *iptr, i;
…
iptr = &i; i değişkenin adresinin 1000 olduğunu varsayalım. iptr nin değeri 1000 dir.
iptr++; iptr nin değeri 1002 olur. ( int değeri işaret ettiği için)

aynı örneği double için yaparsak
double *iptr, i;
…
iptr = &i; i değişkenin adresinin 1000 olduğunu varsayalım. iptr nin değeri 1000 dir.
iptr++; iptr nin değeri 1008 olur. ( double değeri işaret ettiği için)

int *iptr, i, j;
…
iptr = &i; i değişkenin adresinin 1000 olduğunu varsayalım. iptr nin değeri 1000 dir.
*(iptr+4)=2; 1008 adresinin içeriğini 2 yapar.

!!! Arttırma işaret edilen veri bloğuna göre yapılır Yani bir sonraki veri bloğunun gösterilmesi sağlanır.

iptr++ ; bir sonraki veri bloğunu göster
(*iptr)++; iptr değişkeninin gösterdiği adresteki değeri 1 arttır

9.3 İşaretçiler ve Diziler

İşarteçiler üzerinde geçerli aritmetik yardımıyla dizilere işaretçi değişkenler ile erişmek mümkündür.

#include
main()
{
int i[10], j;
int *iptr;

for (j=0; j<10; j++)
i[j]=j;

/* Dizinin başlangıç adresine erişmek için ilk elemanın adresi kullanılabilir &i[0] veya doğrudan */

iptr = i;

clrscr();

for (j=0; j<10; j++) {
printf("%d ", *iptr);
iptr++;
}
printf("\n");
/* iptr artık dizinin başını göstermez */

iptr = i;
for (j=0; j<10; j++)
printf("%d ", *(iptr+j));

printf("\n");
/* iptr hala dizinin başını gösterir */
getch();
}

Örnek 9.3.1: İşaretçi ve dizgi kullanımı.
#include
main()
{
char *a=”1234567890″;
char b[11];
char *p1, *p2;

printf(“%s\n”, a);
p1 = a;
p2 = b;
while (*p1 != ‘\0′) {
*p2 = *p1;
p1++;
p2++;
}
printf(“%s\n”, b);
}

9.4 İşlevleri Referans Yoluyla Çağırma

Şu ana yazdığımız işlevlerde gönderilen parametrelerin (diziler hariç) değerlerinin değiştirilmesi mümkün değil idi. İşlev çağırıldığı zaman parametrelerin bir kopyası çıkartılıp işleve gönderiliyordu. Bir işlevin birden fazla değer gönderebilmesi için işaretçilere gereksinimiz vardır.

void arttir(int);
main()
{
int i;
i = 5;
printf(“öncesi %d\n”, i);
arttir(i);
printf(“sonrası %d\n”, i);
getch();
}
void arttir(int k)
{
k++;
}

Çıktı :
öncesi 5
sonrası 5

Gönderilen parametrenin kopyası işleve gönderildiği için işlev içerisinde yapılan değişiklikler işlevin çağırıldığı yeri etkilemez. Eğer parametredeki değişikliklerin işlevin çağırıldığı yerde de geçerli olmasını istiyorsak işleve parametrenin adresini göndermek gerekir.

void arttir(int*);
main()
{
int i;
i = 5;
printf(“öncesi %d\n”, i);
arttir(&i);
printf(“sonrası %d\n”, i);
getch();
}
void arttir(int *k)
{
(*k)++;
}

öncesi 5
sonrası 6

Örnek 9.4.1: Sayısal dizgiyi tamsayıya dönüştüren işlevde iyileştirme. Geçersiz karakterin konumu da verilsin.
int deger(char *s, int *konum)
konum = -1 ise tüm karakterler rakam
>=0 ise geçersiz karakterin konumu

Örnek 9.4.2 : Sıraya dizme. Yer değişikliği işlevde ve parametrelere referans yolu ile erişim.

#include
#include

#define N 20
void degistir (int *, int *);

main()
{
int s[N];
int i, k;

clrscr();

for (i=0; i s[i] = rand() % 100;
printf("%4d",s[i]);
}
printf("\n");
k=1;
do {
k=0;
for (i=0; i if (s[i] > s[i+1]) {
degistir (&s[i], &s[i+1]);
k = 1;
}
} while (k);

for (i=0; i printf("%4d",s[i]);
printf("\n");
getch();
}

void degistir (int *a, int *b)
{
int gec;
gec = *a;
*a = *b;
*b = gec;
}

!!! Dizilerde işaretçi olduğu için a değişkeni bir dizi(veya işaretçi ise)
a[i] ile *(a+i) ifadeleri aynı anlamı taşır.

Örnek 9.4.3: İşleve gönderilen dizinin işlev içerisinde işaretçi olarak kullanımı.

#include
#include

#define N 5

float ort (int *);

main()
{
int s[N];
int i, k;

clrscr();
for (i=0; i s[i] = rand() % 100;
printf("%4d",s[i]);
}
printf("\n");
getch();
}

float ort (int *a)
{
int i;
float t = 0;

for (i=0; i t = t + *(a+i);

return t/N;
}

Örnek 9.4.5: işleve gönderilen işaretçinin işlev içerisinde dizi olarak kullanımı .

void malloc(n): En az n byte uzunluğunda bellekten yer ayırır. İşlevin değeri
>0 ise bloğun bellekteki yeri, NULL yer yok demektir.

int *i;
i = (int *) malloc(2000) ; 2000 byte yer ayırıp bloğun başlangıç adresini i ‘ye atar
( 1000 elemanlı int dizisi )
double *x;
x = (double *) malloc(8*2000); 2000 elemanlı double dizi

sizeof(n) : n ifadesinin/tipinin byte olarak uzunluğunu verir.
i = (int *) malloc(1000*sizeof(int)) ; 1000 tane int değer içerecek bellek uzunluğu

x = (double *) malloc(2000*sizeof(double)); 2000 elemanlı double dizi

void free (void *block) : mallock işlevivi tersi. Block değişkenin tuttuğu yeri boş belleğe gönderir

#include
#include
#define N 8
float ort (int []);

main()
{
int *s;
int i, k;

s = (int *) malloc(2*N);
clrscr();
for (i=0; i s[i] = rand() % 10;
printf("%4d",*(s+i));
}
printf("\n");

printf("Ortamala = %.2f\n",ort(s));

getch();
}

float ort (int a[])
{
int i;
float t = 0;

for (i=0; i t = t + a[i];
return t/N;
}

Örnek 9.4.6 : Bir dizinin elemanlarının işaretçi olması.

Daha önce yapılan bir örnekte ay isimleri bir dizide saklanmıştı.

main()
{
char *aylar[] = {"", "Ocak", "ªubat", "Mart", "Nisan",
"Mayıs", "Haziran", "Temmuz", "Ağustos",
"Eylül", "Ekim", "Kasım", "Aralık"};
int i;
printf("Ayın sırasını gir "); scanf("%d", &i);
if (i>0 && i<13)
printf("%s\n", aylar[i]);
getch();
}

Benzer şekilde

float *a[100];

tanımlaması her bir elemanı bellekte bir 'float' sayıyı gösteren işaretçi olan 100 elemanlı bir dizidir.

Örnek 9.4.7 : Bir işaretçinin adresini içeren işaretçiler.

main()
{
int i;
int *iptr;
int **iptrptr;

i = 5;
iptr = &i;
iptrptr = &iptr;

clrscr();
printf(" i ve &i : %d %p\n", i, &i);
printf(" *iptr ve iptr : %d %p\n", *iptr, iptr);
printf("*iptrptr ve iptrptr : %p %p\n", *iptrptr, iptrptr);

getch();
}

Ekrana çıktı:
i ve &i : 5 8FDD:1000
*iptr ve iptr : 5 8FDD:1000
*iptrptr ve iptrptr : 8FDD:1000 8FDD:0FFC

9.5 İşaretçiler ve Yapılar

Bir işaretçi işleve parametre olarak gönderildiğinde basit değişken gibi değişkenin kopyası alınıp gönderiliyordu. Yapının büyük olduğu durumlarda bu da sorun çıkartır. İşaretçinin bir yapı verisini göstermesi.

struct ogrenci{
char no[10];
int notu;
};

struct ogrenci *a

Tanımlamasında a değişkenini oluşturan alanlara erişmek için, bilinen yol:

*a.notu=56;
strcpy((*a).no, "95001");

Bunun farklı kullanımı:
a->notu=56;
strcpy(a->no, “95001″);

Örnek 9.5.1 : Yapının adresinin işleve gönderilmesi.

#include
typedef struct {
char adi[35];
char adres1[40];
char adres2[40];
char tel[15];
float borc;
} kisiler;
void yaz(kisiler *z);
main()
{
kisiler a;
clrscr();
printf(“Adını gir : “); gets(a.adi);
printf(“Adres-1 : “); gets(a.adres1);
printf(“Adres-2 : “); gets(a.adres2);
printf(“Telefonu : “); gets(a.tel);
printf(“Borcu : “); scanf(“%f”, &(a.borc));

yaz(&a);
}
void yaz(kisiler *z)
{
clrscr();
printf(“Adı : “); puts(z->adi);
printf(“Adresi : “); puts(z->adres1);
printf(” : “); puts(z->adres2);
printf(“Telefonu : “); puts(z->tel);
printf(“Borcu : “); printf(“%.0f\n”, z->borc);
}

9.6 Dinamik bellek kullanımı

Üç boyutlu dizi tanımı ve kullanımı.

Üç boyut –> Gerilim – Akım – Zaman

Örnek 9.6.1: Tek boyutlu diziyi üç boyutlu gibi kullanma.

/* Üç boyutlu dinamik dizi kullanımı. Her boyut farklı uzunlukta
Dizi tek boyutlu gözüküyor. Ancak indis, hesaplanarak bulunuyor

Yani

*(a + i*y*z + j*z +k)
^ ^
^ ^ 3. boyutun uzunluğu
^2. boyutun uzunluğu

şeklinde kullanılabilir.
*/

#define x 4
#define y 5
#define z 9
void matris_yaz(int *);
main()
{
int *a;
int i, j, k;

a=(int *) malloc(x * y * z * sizeof(int)); /* eleman sayisi kadar yer ac */

clrscr();

for (i=0; i printf("i = %d \n", i);
for (j=0; j for (k=0; k *(a + i*y*z + j*z +k) = i*j*k;
printf("%5d ",*(a + i*y*z + j*z +k));
}
printf("\n");
}
}

matris_yaz(a);

}

void matris_yaz(int *m)
{
int i, j, k;

clrscr();
for (i=0; i printf("i = %d \n", i);
for (j=0; j for (k=0; k printf("%5d ",*m);
*m++;
}
printf("\n");
}
getch();
}
}

Örnek 9.6.2:
/* Uc boyutlu dinamik dizi kullanimi. Her boyut farkli uzunlukta
Bu yontem ile diziye normal dizi gibi erismek mumkun
Yani
a[i][j][k]
seklinde kullanilabilir.
*/

#define x 8
#define y 4
#define z 10
main()
{
/*
typedef int *boyut1;
typedef boyut1 *boyut2;
typedef boyut2 *boyut3;

boyut3 a;
*/
double ***a;

int i,j,k;

a=(double *) malloc(x*sizeof(double*)); /* 1. boyut icin yer ayir (işaretçiler) */
for (i=0; i *(a+i)=(double *) malloc(y*sizeof(double*)); /* 1. boyutun her elemani n */
/* elemanli diziyi gosterir */

for (i=0; i for (j=0; j *(*(a+i) + j) = (double *) malloc(z*sizeof(double));

clrscr();

for (i=0; i for (j=0; j for (k=0; k *(*(*(a + i) + j) + k) = i*j*k;
for (i=0; i printf("i = %d \n", i);
for (j=0; j for (k=0; k printf("%4.1f ",a[i][j][k]);
printf("\n");
}
getch();
}
}

9.7 İşaretçilerle İlgili Diğer Konular

İşaretçinin Belirli Bir Adresi Göstermesi

#include
#include
char far *ekran;
void kaydir_Y(void);
void kaydir_A(void);
void main()
{
int i, j;
char c;

ekran = MK_FP(0xB800, 0);
clrscr();
for (i=0; i<25; i++)
for (j=0; j<80; j++)
ekran[160*i+2*j] = 65+i;

while (1) {
c = toupper(getch());
switch(c) {
case 'A' : /* yukari */
kaydir_Y();
break;
case 'Z' : /* asagi */
kaydir_A();
break;
case 'Q' : exit(0);
}
}
}
void kaydir_Y(void)
{
int i, j;
for (i=8; i<=12; i++)
for (j=30; j<60; j++)
ekran[160*(i-1) + 2*j] = ekran[160*i + 2*j];
}
void kaydir_A(void)
{
int i, j;
for (i=12; i>=8; i–)
for (j=30; j<60; j++)
ekran[160*(i+1) + 2*j] = ekran[160*i + 2*j];
}

İşlev İşaretçileri

İşaretçinin bir işlevin bulunduğu adresi içermesi durumudur. Normal işaretçi gibi işlevin adresini içeren değişken tanımı yapılmalıdır. Örneğin;

int (*fnptr) (int, int)

fnptr değişkeni iki tane int parametresi olup bir int değer geri gönderen bir işlevin adresini içerebilir.

(int *fnptr (int, int) : iki int parametresi olup int işaretçi geri gönderir )

Örnek 9.7.1: Aynı isim ile farklı iki işlevi çağırma.

int kare(int);
int kub(int);
main()
{
int (*islem)(int); /* bir int değer alıp geriye int değer gönderen bir işlevin adresi */
int i;
char c;

clrscr();

printf("1 / 2 : kare / küb hesabı : ");

c = getch();
printf("\nSayıyı gir : ");
scanf("%d", &i);

if (c == '1')
islem = kare; /* kare işlevinin adresi islem değişkenine kopyalanır */
else
islem = kub;

printf("Sonuç = %d\n", islem(i));

getch();
}

int kare(int s)
{
return s*s;
}

int kub(int s)
{
return s*s*s;
}

Void İşaretçiler

İşaretçiler void olarak tanımlanabilir. Bu biçimde tanımlanan işaretçilerin gösterdiği adresteki değere erişmek için veri tipi belirtilmelidir.

main()
{
void *a;

a = (char*) malloc(10);
strcpy(a,"12345");

printf("%s\n", a);
free(a);

a = (double*) malloc(sizeof(double));
*(double*)a = 3.123; /* değere erişirken veri tipi belirt */
printf("%f\n", *(double *)a);

getch();
}

10. Daha Önce Geçmeyen Konular

Deyimler
continue: Döngünün herhangi bir satırında iken, bir sonraki döngü admını geçilmesini sağlar.

Örnek 10.1:
#include
int main()
{
int i;

for(i = 1 ; i < 10 ; i++)
{
if (i == 5)
break;
printf("%d\n", i);
}

for(i = 1 ; i < 10 ; i++)
{
if (i == 5)
continue;
printf("%d\n", i);
}
}

gotoxy(x, y) : İmleci metin ekranında istenilen noktaya taşır.
void gotoxy(int x, int y)
gotoxy(25, 23);
printf("Bir tuşa basınız.");

wherex(), wherey() : Bulunulan yer

exit: Herhangi bir yerde programın çalışmasını sonlandırır.
void exit(int durum); : Dosyalar kapatılır, durum parametresinin değeri programın çağırıldığı yere geri gönderilir.

goto : Programın herhangi bir yerinden başka bir yere atlanmasını sağlar ( aynı işlev içerisinde).
Gidilecek yerin tanımlanması gerekir. Kulanım şekli;
goto son programın akışı son: etiketinin alduğu yerden devam eder
...
son :
return;

Örnek: Matriste sıfırdan küçük değerli ilk elemanın yerini bulan program.
#include
main()
{
int a[10][10];
int i, j;

randomize();

for (i = 0; i<10; i++)
for (j = 0; j<10; j++)
a[i][j] = (rand() % 100) - 20;

for (i = 0; i<10; i++)
for (j = 0; j<10; j++)
if (a[i][j] < 0)
goto bulundu;

printf("Sıfırdan küçük sayı yok\n");
goto son;

bulundu:
printf("Sayının konumu ve değeri (%d, %d) = %d \n",i, j, a[i][j]);

son:
return 0;
}

? : İşleci
değişken = mantıksal ifade ? ifade1 : ifade2
mantıksal ifade doğru is değişkene ifade1, yanlış ise ifade2 değeri atanır.

a = (i == 5) ? 1 : 0;
Eğer i'nin değeri 5 ise a'ya 1, aksi halde 0 atanır. Aynı ifade açık olarak yazılırsa;
if (i ==5)
a = 1;
else
a = 0;

Örnek 10.2:
main()
{
int a;
int i, j;

scanf("%d%d", &i, &j);

a = (i > j) ? i : j;

printf(“%d\n”, a);
}

Bileşik Atama İşleci
a = a + b işlemi a += b şeklinde de yazılabilir. = işleci ile birlikte bu şekilde kullanılabilen diğer işleçler;
* / % + – << >> & ^ |

Bu işleçler için
a = a işleç b ile
a işleç= b
aynı anlamı taşır.

Virgül İşleci
Şu ana kadar kullanılan biçim dışında,
Birden fazla deyimin aynı ifadede yürütülmesini sağlar. İfade tek bir sonuç verecek ise parantez içerisine alınmalıdır. İfadeler soldan sağa yürütülür ve son ifade parantez içi ifadenin değeri olur.

i = (5, 3, 8); i = 8
i = (j = 2; j = j + 5); i = 7

for döngüsünün bölümlerinde birden fazla deyim yürütmede kullanılır.

for (t = 0, i = 0; i<100; i++)
t = t + i;

Geçici Veri Tipi Değiştirme
(type cast)
Bir değerin tipinin geçici olarak değiştirmek mümkündür. Kullanım şekli,.
(veri tipi) ifade;

ifade (değişken, sabit) tipi belirtilen tipe dönüştürülür.

Örnek 10.3:
#include
main()
{
float a, b;
int i, j;

i = 500;
j = 500;

a = i * j;
b = (float) i*j;

printf(“%f %f\n”, a, b);

}
-12144.000000 250000.000000

İfade İçerisinde Atama Deyimi Kullanma

#include
main()
{
char c;
while ((c=getch()) != ‘S’)
printf(“%c”, c);
printf(“\n%c tuşuna bastınız\n”, c);
getch();
}

((c=getch()) != ‘S’) ifadesinde ilk önce en içteki parantez c = getch() yürütülür. Daha sonra karşılaştırma işlemi yapılır.

++ / — İşleçleri

İfade içerisinde değişkenin
ardında ise değişkenin değeri ifadede kullanılır ve değeri bir arttırılır
önünde ise değişkenin değeri değeri bir arttırılır ve yeni değeri ifadede kullanılır.
i = 2;
k = 5*i++; –> k = 10
k = 5*++i; –> k = 15

#define Önişlemcisi

define önişlemcisi ile işlev benzeri makrolar yazmalar mümkündür.

#define kub(x) ((x)*(x)*(x))
main()
{
int i;

i = 5;
printf(“%d \n”, kub(i));
}
Makro tanım satırında parametrelerin parantez içerisine alınması unutulmalı.

Makro kub(i+1) biçiminde çağırıldığında, i=2 için

((x)*(x)*(x)) –> (i+1)*(i+1)*(i+1) –> 27

(x * x * x) –> (i+1* i+ 1* i+1) –> 6

#define ustal(a, b) (pow((a), (b)))

11. Grafik

Basit grafik işlemleri nasıl gerçekleştirilir (sorumlu değiller).
Normal çalışma anında text ekranda (25, 80) boyutlarında.
* void textbackground(int newcolor); : alt zemin rengi
* void textcolor(int newcolor); : yazı rengi
* void textattr(int newattr); 8 bitlik sayı. hem alt zemin hem de yazı rengi
verilir Bbbbffff (B = blink)

* void highvideo(void); Yazı parlaklığı
* void lowvideo(void);
* void normvideo(void);

Bu işlevler doğrudan ekrana yazan deyimlere yöneliktir (cprintf, cput)
#include
main()
{
int i;
textbackground(BLACK);

clrscr();

for (i=0; i<=15;i++) {
textcolor(i);
cputs("HÜSEYİN PEKTAŞ\r\n");
}

getch();
}

Grafik çizimi için bilgisayarın grafik modunda olması gerekir.

/*
* void far initgraph(int far *graphdriver, int far *graphmode, char far *pathtodriver);
Grafik sistemini verilen degerlere gore ayarlar. Grafik komutlarini kullanmadan once calistirilmalidir.

* closegraph; Grafik sistemini kapatir.
* graphresult: int; Grafik islemi ile ilgili bilgi verir.
* char *far grapherrormsg(int errorcode); Belirtilen grafik hatasi icin mesaji verir.

* line(x1, y1, x2, y2);
* lineto(x, y); Bulunulan yerden (x,y) ye kadar çizer
* linerel(x, y); Bulunulan yerin (x,y) ötesine kadar çizer
* moveto(x, y);

* void far cleardevice(void); Grafik ekranını siler

* circle(x, y , r);

* putpixel(x, y, renk);
* getpixel(x, y); Belirtilen noktanin piksel degerini verir

* getx; Bulunulan
* gety; noktalar

* getmaxx; Maksimum olabilecek
* getmaxy; noktalar

* outtext(char far *) : Bulunulan yere metni yazar
* outtextxy(x, y, char far *) : Belirtilen yere metni yazar

* int far getcolor(void); : çizim rengi öğren
* void far setcolor(int color); : çizim rengini değiştir

* int far getbkcolor(void); : alt zemin rengini öğren
• void far setbkcolor(int color);: alt zemin rengini değiştir

EGA_BLACK EGA_BLUE EGA_GREEN EGA_CYAN EGA_RED EGA_MAGENTA EGA_LIGHTGRAY EGA_BROWN 0 1 2 3 4 5 7 20 EGA_DARKGRAY EGA_LIGHTBLUE EGA_LIGHTGREEN EGA_LIGHTCYAN EGA_LIGHTRED EGA_LIGHTMAGENTA EGA_YELLOW EGA_WHITE 56 57 58 59 60 61 62 63

#include
#include
#include
#include

main()
{
int gd, gm, hata;
int x, y;

gd = DETECT; /* ekran sürücüsünü otomatik tanı */
/* CGA, HERC, VGA..*/

initgraph(&gd, &gm, “c:\\diller\\tc3\\bgi\\”);
/* gd gm
VGA ¦ VGALO ¦ 0 ¦ 640 x 200 ¦ 16 color¦ 2
9 ¦ VGAMED ¦ 1 ¦ 640 x 350 ¦ 16 color¦ 2
¦ VGAHI ¦ 2 ¦ 640 x 480 ¦ 16 color¦ 1
*/
hata = graphresult();

if (hata != grOk) /* grOk = 0 tanımlı */
{
printf(“Grafik hatası: %s\n”, grapherrormsg(hata));
getch();
exit(1);
}

x = getmaxx();
y = getmaxy();

setbkcolor(EGA_RED);
setcolor(EGA_YELLOW);
cleardevice();

line(0, 0, 0, y);
line(0, y, x, y);
line(x, y, x, 0);
line(x, 0, 0, 0);

getch();

cleardevice();

moveto(50, 50);
lineto(50, 100);
lineto(100,100);
lineto(100,50);
lineto(50, 50);

getch();

closegraph();
}

Örnek 11.1: İşlev çizimi
#include
#include
#include
#include

double fonk(double x);
double fonk1(double x);

main()
{
int gd, gm, hata;
double x, y;
int orgx, orgy;

gd = DETECT;
initgraph(&gd, &gm, “c:\\diller\\tc3\\bgi\\”);
hata = graphresult();
if (hata != grOk)
{
printf(“Grafik hatası: %s\n”, grapherrormsg(hata));
getch();
exit(1);
}

orgx = 20;
orgy = getmaxy() / 2;

line(0, orgy, getmaxx(), orgy); /* x ekseni */
line(20, 0, 20, orgy+50); /* y ekseni */

outtextxy(getmaxx()-50, orgy-10, “Zaman”);
outtextxy(22, 0, “Volt”);

for (x = 0; x< 6.28; x = x + 0.005) {
y = fonk1(x);
putpixel(orgx + 80*x, orgy - y, 2); /* renk yeşil EGA_GREEN*/
/* - çünkü eksenin üzerinde çizsin */

}

getch();

closegraph();
}

double fonk(double x)
{
double y;
y = 100 * sin(10 * x);
return y;
}
double fonk1(double x)
{
double y;
y = 1 - exp(-x);
return 200*y;
}

12. KÜTÜKLER

12.1 TEXT Kütükler
(sıralı erişim, ascii, metin)

Kütük(file): Bilgilerin diskte saklanış biçimi.

Text kütüğü :
- karakterlerden oluşur.
- her satırın sonunda satır sonunu gösterir özel karakter '\n' vardır.
- kütüğün sonunda kütük sonunu gösterir özel karakter 'eof' vardır.

Örnek:
Birinci satır<\n>
Bu da ikincisi<\n>
Diskte satırlar peşpeşedir. İlk satırdaki <\n> karakterinden hemen sonra ikinci satırın ilk karakteri gelir.

Kütüklerin Kullanımı

Bir kütüğü kullanmadan önce iki işlemim yapılması germektedir. Kütük ile ilgili işaretçinin tanımlanması ve kütüğün açılması.

Tanımlı FILE tipinde işaretçi değişken tanımlayarak ilk işlem gerçekleştirilir.
FILE *kp; /*FILE yapısı stdio.h içerisinde tanımlı */

İkinci aşamada kütük açma deyimi kullanılır.
kp = fopen(kütük adı, mod)

kütük adı : açmak istediğimiz kütüğün adı (string). Büyük – küçük harf ayrımı yok.
mod : kullanım amacı (string). Okuma, yazma değişiklik …

r : okumak için
w : yazmak için. Kütük yok ise oluşturulur, var ise içeriği silinir.

a : eklemek için. Kütük yok ise oluşturulur , var ise sondan itibaren yazılır
r+ : Var olan bir kütüğü okumak ve yazmak için
w+ : Okumak ve yazmak için yeni bir kütük oluştur. Dosya var ise içeriği silinir.
a+ : Eklemek için. Okuma ve yazma yapılabilir. . Dosya yok ise oluşturulur..

Örnek 12.1.1 : Kütüğe yazma
#include
main()
{
FILE *kp;
char *s;
int i;

kp = fopen(“dene”, “w”); /* NULL ise işlem başarısız */
if (kp == NULL)
exit(1);

for (i=0; i<5; i++) {
gets(s);
fprintf(kp, "%s\n", s);
}
getch();
fclose(kp); /* kütüğü kapatır. Program sona erdiğinde otomatik kapatılır */
/* fcloseall() hepsini kapatır. Dönen , kapanan kütük sayısı. Hata var ise EOF döner
*/
}

Yazarken kullanılan fprintf deyiminin çalışması printf gibidir. Sadece ilk parametre olarak kütük değişkenini vermek gerekir.

Benzer kütük işlevleri

int fgetc(FILE *stream);
int fputc(int c, FILE *stream);
char *fgets(char *s, int n, FILE *stream); n-1 karakter veya satır sonuna kadar okur
int fputs(const char *s, FILE *stream); satır sonu bilgisini ayrıca yazmak gerekir

Örnek 12.1.2: Kütükten okuma

#include
main()
{
FILE *kp;
char *s;
int i;

kp = fopen(“dene”, “r”);
if (kp == NULL)
exit(1);

clrscr();
for (i=0; i<5; i++) {
fscanf(kp, "%s", s);
printf("%s\n", s);
}

/* Kütükteki kayıt sayısı bilimiyor ise */
rewind(kp);
/* fseek(stream, 0L, SEEK_SET)
SEEK_SET 0 baştan
SEEK_CUR 1 bulunulan yerden
SEEK_END 2 sondan
*/
fscanf(kp, "%s", s);
while (!feof(kp)) {
printf("%s\n", s);
fscanf(kp, "%s", s);
}
getch();
}

int feof(FILE *) : kütüğün sonuna erişilmiş ise sıfırdan farklı bir değer alır. Aksi halde sıfırdır.
rewind(FILE *) : kütük işaretçisinin (kütükteki hangı kayıdın okunacağı bilgisi) kütüğün başını göstermesini sağlar.

Örnek 12.1.3: Ekleme ve okuma

a+ modunda kütük aç. + eklenmez ise kütük işaretçisi kütük başına taşınmıyor

#include
main()
{
FILE *kp;
char *s;
int i;

kp = fopen(“dene”, “a+”);
if (kp == NULL)
exit(1);

clrscr();
for (i=0; i<2; i++) {
gets(s);
fprintf(kp, "%s\n", s);
}
rewind(kp);
fscanf(kp, "%s", s);
while (!feof(kp)) {
printf("%s\n", s);
fscanf(kp, "%s", s);
getch();
}
getch();
}

Örnek 12.1.4: Matrisin elemanlarının değerlerinin kütükten öğrenilmesi.
kütüğün ismi matrisa.dat
matris elemanları double
boyut 4x3

#define SAT 4
#define SUT 3
#include
main()
{
FILE *kp;
double a[SAT][SUT];
int i, j;

kp = fopen(“matrisa.dat”, “r”);
if (kp == NULL)
exit(1);

for (i=0; i for (j=0; j fscanf(kp, "%lf", &a[i][j]);

clrscr();

for (i=0; i for (j=0; j printf("%8.1f", a[i][j]);
printf("\n");
}

getch();
}

Örnek 12.1.5: Hesaplanan değerlerin kütüğe yazdırılması.
1-exp(-x) fonksiyonu 0-10 aralığında 0.02 adımlarla hesaplanıp kütüğe yazılıyor

#include
#include

#define ADIM 0.02
#define T0 0
#define TS 10

main()
{
FILE *kp;
double f, t;

kp = fopen(“sonuc.dat”, “w”);
if (kp == NULL)
exit(1);
for (t=T0; t f = 1 - exp(-t);
fprintf(kp, "%6.3f %12.8f\n", t, f);
printf("%6.3f %12.8f\n",t, f);
}
getch();
}

12.1.1 Text Kütükte Değişiklik

Kütük işaretçisi değişiklik yapılacak kaydı göstermelidir. Ayrıca yeni bilgi eski bilgi ile aynı olmalıdır. Bu nedenle text kütüklerde değişiklik başvural bir şey değil. Gerektiği durumlarda kayıtlar geçici olarak başka bir kütüğe yazılır.

int remove(const char *k_adi) : kütüğü siler
int rename(const char *eski, const char *yeni) : kütüğün ismi değiştirilir

Örnek 12.1.6: Girilen dosyada herbir harfin kaçdefa geçtiğini bulup, çoktan aza doğru yazar.

#include
#include

void degistir(int *, int *);

main(int argc, char *argv[])
{

char dosyaadi[64];
FILE *fp;
char c;

long toplam = 0;
int frek[2][26] = {0,};
int i, j, k;

for (i=0; i<26; i++)
frek[0][i] = 65 + i;

if (argc<2) {
printf("Dosya adını belitmediniz\n");
exit(1);
}
else
strcpy(dosyaadi, argv[1]);

fp = fopen(dosyaadi, "r");

while (!feof(fp)) {
c = toupper(fgetc(fp));
if (c >= ‘A’ & c <='Z' )
frek[1][c - 'A']++;
}

for (i = 0; i < 26; i++)
toplam = toplam + frek[1][i];

clrscr();
printf("İncelenen Dosya : %s\n", dosyaadi);
printf("Toplam harf : %ld", toplam);

/* Çoktan aza doğru sırala */
do {
k = 0; /* bayrak */
for (i=0; i < 25; i++)
if (frek[1][i] < frek[1][i+1] ) {
k = 1;
degistir(&frek[0][i], &frek[0][i+1]);
degistir(&frek[1][i], &frek[1][i+1]);
}
} while (k == 1);

for (i = 0; i < 26; i++) {
if (i<13)
gotoxy(1, 5+ i);
else
gotoxy(40, 5 + i - 13);

printf("%c: %6d %5.3f",frek[0][i] , frek[1][i], (float)frek[1][i]/toplam);
}

getch();
}

void degistir(int *a, int *b)
{
int c;
c = *a;
*a = *b;
*b = c;
}

Örnek çıktı: (frekans classics.txt)

İncelenen Dosya : classics.txt
Toplam harf : 122850

E: 14657 0.119 M: 2870 0.023
T: 10449 0.085 F: 2630 0.021
A: 9902 0.081 P: 2440 0.020
I: 9889 0.080 Y: 2292 0.019
S: 9504 0.077 W: 2257 0.018
O: 9492 0.077 G: 2172 0.018
N: 8521 0.069 B: 1779 0.014
R: 7706 0.063 V: 1279 0.010
H: 6215 0.051 K: 1260 0.010
L: 5333 0.043 Z: 288 0.002
D: 4463 0.036 J: 236 0.002
C: 3760 0.031 X: 218 0.002
U: 3121 0.025 Q: 117 0.001

12.2 Rastgele Erişimli Kütükler

- Veriler sabit uzunluktaki bloklar (kayıt) şeklinde saklanır.
- Veriler karekterler dizisi biçiminde saklı.
- Değişkenlerin içeriği bellekte saklanış biçimiyle kütüğe yazıldığı için okuma/yazma işlemleri text kütüklere göre daha hızlı.
- Aynı sebepten dolayı veriler kütükte daha az yer kaplar.
- Gerçel sayılarda hassasiyet kayıbı yok.
- İstenilen kayıda doğrudan erişmek mümkün.

Bilgiler sabit uzunlukta saklandığı için değişiklik anında kayıt bozulması yok
İstenilen bilgiye erişmesi kolay.

Kütüklerin Bu Biçimde Kullanılması İçin

fwrite ve fread deyimleri kullanılır

fwrite(veri_ptr, uzunluk, kac_tane, kp) : Belirtilen sayıda sabit uzunluktaki veriyi kütüğe yazar

veri_ptr : Yazılacak veriye işaretçi
uzunluk : Yazılacak verinin uzunluğu
kac_tane : Verinin kaç defa ard arda yazılacağı
kp : Kütük işaretçisi

Kütüğe uzunluk * kac_tane kadar byte yazılır. Dönüş değeri
yazılan veri sayısı ( byte değil)

fead(veri_ptr, uzunluk, kac_tane, kp) : Belirtilen sayıda sabit uzunluktaki veri kütükten okunur
Örnek 12.2.1: Rastgele erişimli kütük

#include
#include
#include

typedef struct {
char no[11];
int notu;
} ogryapi;

FILE *kp;
ogryapi ogr;

void giris(void);
void liste(void);

main()
{
int i;
char c;

kp = fopen(“ogr.dat”, “r+”);

if (kp == NULL) {
printf(“%d\n”, errno); /* 2 ise file not found */
kp = fopen(“ogr.dat”, “w+”);
}
do {
clrscr();
fseek(kp, 0, 2);
printf(“Dosya uzunluğu %ld\n”, ftell(kp));
printf(“Kayıt sayısı %d\n\n”, ftell(kp) / sizeof(ogryapi));

printf(“1-Giriş\n2-Liste\n3-Çıkış\n”);
c = getch();
switch (c) {
case ’1′: giris(); break;
case ’2′: liste(); break;
case ’3′: exit(0);
};
} while (1);

void giris(void)
{
int i;

clrscr();

printf(“Öğrenci no : “); scanf(“%s”, ogr.no);
printf(” Notu : “); scanf(“%d”, &ogr.notu);

i = atoi(ogr.no);

fseek(kp, (i-1)*sizeof(ogryapi), 0);
fwrite(&ogr, sizeof(ogryapi), 1, kp);

fflush(kp);
/*int fflush(FILE *) tampon bllektekiler diske yazılır
int flushall(void)
*/

}

void liste(void)
{
clrscr();
fseek(kp, 0, 0);
fread(&ogr, sizeof(ogryapi), 1, kp);
while (!feof(kp)) {
printf(“%s %d\n”, ogr.no,ogr.notu);
fread(&ogr, sizeof(ogryapi), 1, kp);
}
getch();
}

Örnek 12.2.2 : Dizinin kütüğe yazılması, okunması

#include
#include

#define MAX 10

FILE *kp;
int a[MAX];

void giris(void);
void liste(void);

main()
{
Önceki örnek gibi
}

void giris(void)
{
int i;

clrscr();
for (i=0; i a[i] = rand() % 100;

fseek(kp, 0, 0);
fwrite(a, sizeof(int), MAX, kp);
}

void liste(void)
{
int i;
clrscr();

fseek(kp, 0, 0);
fread(a, sizeof(int), MAX, kp);

for (i=0; i printf("%d ", a[i]);

printf("\n");
getch();
}

EK A. Örnekler

Örnek A.1: Paralel portun kullanımı
/* PC deki paralel porta erişim
oku : paralel portu okur. Eski tip portlar çift yönlü olmadığı için
durum uçları giriş amaçlı kullanıldı
( 4-bit , bi-directiona, EPP, ECP )

yaz : paralel port data uçlarına bilgi gönderir

oku_yaz : durum uçlarından okuduğunu veri uçlarına gönderir

*/

#include
#include
#include

typedef unsigned word;

void binary_yaz(word);
void oku(void);
void yaz(void);
void oku_yaz(void);
word pdata=0×378;
word pstat=0×379;
word bout, bin;
char c;

main()
{

do {
clrscr();
printf(“1 – Oku\n”);
printf(“2 – Yaz\n”);
printf(“3 – Okuduğunu Yaz\n”);
printf(“4 – Çık\n”);

c = getch();
switch(c) {
case ’1′ : oku(); break;
case ’2′ : yaz(); break;
case ’3′ : oku_yaz(); break;
case ’4′ : exit(0);
}
} while (1);
}

void yaz(void)
{
clrscr();
printf(“Gönderilecek veri :”);
scanf(“%d”, &bout);
binary_yaz(bout); printf(“\n”);
outport(pdata, bout);
c = getch();
}
void oku(void)
{
clrscr();
do {
bin = inportb(pstat);
binary_yaz(bin);
printf(” %d\n”, bin);
c = getch();
} while (c != ‘q’);
}

void oku_yaz(void)
{
clrscr();
do {
bin = inportb(pstat);
gotoxy(1,8) ; printf(“Okunan = “);
binary_yaz(bin);
outport(pdata, bin);
gotoxy(1,9) ; printf(“Yazılan = “);
binary_yaz(bin);

printf(” %d\n”, bin);
c = getch();
} while (c != ‘q’);
}

void binary_yaz(word x)
{
word i;
word m;

m = 0×8000;
for (i = 0; i<16; i++) {
if (x & m)
printf("1");
else
printf("0");
m = m >> 1;
}
printf(” “);
}

Örnek A.2. Kesme (interrupt) kullanımı

Intel 8086 Registers

General Purpose Registers AH/AL AX (EAX) Accumulator BH/BL BX (EBX) Base CH/CL CX (ECX) Counter DH/DL DX (EDX) Data (Exx) 386+ 32 bit register Segment Registers CS Code Segment DS Data Segment SS Stack Segment ES Extra Segment (FS) 386 and newer (GS) 386 and newer

Pointer Registers Stack Registers

SI (ESI) Source Index SP (ESP) Stack Pointer
DI (EDI) Destination Index BP (EBP) Base Pointer
IP Instruction Pointer

FLAGS – Intel 8086 Family Flags Register
0 CF Carry Flag 1 1 2 PF Parity Flag 3 0 4 AF Auxiliary Flag 5 0 6 ZF Zero Flag 7 SF Sign Flag 8 TF Trap Flag (Single Step) 9 IF Interrupt Flag A DF Direction Flag B OF Overflow flag C,D IOPL I/O Privilege Level (286+ only) E NT Nested Task Flag (286+ only) F 0 10 RF Resume Flag (386+ only) 11 VM Virtual Mode Flag (386+ only)

#include
#include
main()
{
union REGS a;

clrscr();
a.h.ah = 0x2A; /* Dos servislerinden 2Ah = get system date */
int86(0×21,&a,&a); /* int 21h dos servisleri */

printf(“makinanin tarihi = %d/%d/%d\n”, a.h.dl, a.h.dh, a.x.cx);

a.h.ah = 0×36; /* Diskteki bos alan */
a.h.dh = 0; /* bulunulan, A=1 */
int86(0×21,&a,&a);

printf(“makinanadaki yer = %ld\n”, (long)a.x.ax*a.x.bx*a.x.cx);

getch();
}

ÖRNEKLER

Örnek : 1996-97 2.dönem vize
/*Soru 1 */
#include
#include

char *kelime(char *);

main()
{
char *cumle = “ali zil caldi mi”;
char *s, *kelimeler[20];
int i, kk = 0;
clrscr();

/* yol 1:
s = kelime(cumle);
while (strlen(s)) {
strcpy(kelimeler[kk++], s);
s = kelime(cumle);
}
*/

/* yol 2: strtok islevini kullanarak
s = strtok(cumle, ” “);
while (s !=NULL) {
strcpy(kelimeler[kk++], s);
s = strtok(NULL, ” “);
}
*/

for (i=kk-1; i>=0; i–)
printf(“%s “, kelimeler[i]);

getch();
}

char *kelime(char *s)
{
char a[20], *b, d[20];
int i;
while (s[0] == ‘ ‘)
s++;

strcpy(d, s);

b = strchr(s, ‘ ‘);
if (b == NULL)
strcpy(a, s);
else
{
i = abs(b-s);
strncpy(a, d, i);
a[i] = ‘\0′;
}
strcpy(s, b);
return a;
}

/* Soru 3
struct veriler {
double ka, ya, yg;
};
struct veriler a[60000];

for (i=0; i<60000; i++)
if (a[i].ka == a[i].ya)
printf("%f %f\n",i*20, a[i].ka);
Soru 3*/

EK B. DİNAMİK VERİ YAPILARI

Self-referential structure : üye, tanımlı olduğu yapıya bir işaretçi
struct yapi {
char adi[21];
struct yapi *ptr;
};

B.1 Sıralı Bağlı Liste

.....

Örnek B.1: Sıralı bağlı listenin gerçekleştirilmesi.

#include
#include
struct listyapi {
char adi[21];
struct listyapi *sonraki;
};
typedef struct listyapi listnode;
typedef listnode *listptr;
listptr headnode; /* Herzaman listenin baţýný gösterir */

void seeklist(char *searchthis, listptr *prevnode)
{
listptr c;

c = headnode;
*prevnode = c;
while ((c->sonraki != NULL)) {
c = c->sonraki;
if (strcmp(c->adi, searchthis) >= 0) break;
*prevnode = c;
}
}

void kayit(char *s)
/* prevnode kayıdı newnode kayıdını, newnode kayıdı prevnode’nin daha önce gösterdiği kayıdını gösterir. */
{
listptr newnode, prevnode;

newnode = malloc(sizeof(listnode)); /* yeni kayıda yer a‡ */

strcpy(newnode->adi, s); /*bilgiyi yeni kayıda yaz */

seeklist(newnode->adi, &prevnode); /* listedeki yerini bul */

newnode->sonraki = prevnode->sonraki; /* listeye ekle */
prevnode->sonraki = newnode;
}

void iptal(char *s)
/* newnode kayıdı silinir. prevnode kayıdı newnode kayıdının gösterdiği kayıdını gösterir. */
{
listptr newnode, prevnode;

seeklist(s, &prevnode);
newnode = prevnode->sonraki;
prevnode->sonraki = newnode->sonraki;
free(newnode);
}

void listlist(void)
{
listptr currentnode;

currentnode = headnode;
if (currentnode != NULL) currentnode = currentnode->sonraki;
while (currentnode != NULL)
{
printf(“%s “,currentnode->adi);
currentnode = currentnode->sonraki;
}
printf(“\n”);

} /* Procedure listlist; */

main()
{
char sec;
char *s;

headnode = malloc(sizeof(*headnode));
strcpy(headnode->adi,” listenin baţý”);
headnode->sonraki = NULL;

do {
clrscr();
printf(“Boş yer : %ld\n\n”,coreleft());

listlist();

printf(“\n\n1 – Giriş\n2 – iptal\n3 – Son\n\nSeç \n”);

sec = getch();
switch (sec) {
case ’1′:
printf(“Adı “); gets(s);
kayit(s);
break;

case ’2′: printf(“Adı \n”); gets(s);
iptal(s);
break;

case ’3′: exit(0);break;
}
} while (1);
}

Problem : Polinomlar sıralı bağlı listede saklı. İki polinomun toplamını üçücnü polinomda oluşturan program

B.2 Listelerin Özel Biçimleri (Uygulamaları)

B.2.1 Stack (yığın) : Son giren ilk çıkar (LIFO)
(Fonksiyon çağırıldığında geri dönüş adresi, Fonksiyona gönderilecek parametreler )

Örnek B.2.1: Stack kullanarak girilen cümleyi kelimeleri bozmadan tersten yazdır
#include
#include
struct stackyapi {
char deger[50];
struct stackyapi *sonraki;
};
typedef struct stackyapi stacknode;
typedef stacknode *stackptr;
stackptr top;

void push(char *gelen)
{
stackptr newnode;
newnode = malloc(sizeof(stacknode));
strcpy(newnode->deger, gelen);
newnode->sonraki = top;
top = newnode;
}

int pop(char *giden)
{
stackptr oldnode;

if (top != NULL) {
oldnode = top;
strcpy(giden, top->deger);
top = top->sonraki;
free(oldnode);
return 0;
}
else
return 1; /* yığın boş */
}

main()
{
char *kelime, *cumle;
stackptr current;

top = NULL;
clrscr();
printf(“Cumleyi girin : “); gets(cumle);
kelime = strtok(cumle, ” “);
while (kelime) {
push (kelime);
kelime = strtok(NULL, ” “);
}
kelime = (char *) malloc(20); /* kelime NULL idi, yer açalım*/
while (!pop(kelime))
printf(“%s “, kelime);

printf(“\n”);
getch();
}

Problem :

infix : operand operator operand 2 + 7
postfix : operand operand operator 2 7 +
Soldan sağa işlem yapılır. Öncelik (parantez) yok.

postfix biçimindeki ifadeyi hesaplama ?
infix  postfix dönüşümü ?

B.2.1: Kuyruk (queue) ilk giren ilk çıkar (FIFO)

Bilgisayarda çoklu işlem
Yazıcıyı ortak kullanım

B.2.3: Ağaç (tree) Doğrusal olmayan yapı
İkili ağaç (kök, çocuk, yaprak, derece)

MEMORY MODELLERİ

Tiny : Code + data + stack aynı 64 K lık segment te
Small : Code için 64 K, data + stack ayrı 64 K lık segment
Medium : Code için far pointer ( yani 1 MB code) , data 64 K ( data kullanmayan uzun programlar)
Compact: Medium un tersi. ( çok data kullanan kısa programlar)
Large : Code için 1 MB, data için 1 MB
Huge : Large ile aynı fakat static data 64 K dan fazla olabilir.
YILMAZ TAŞKIRAN

movf OffsetL,W
call DoTable

movlw High(here)
movwf PCLATH ; reset PCLATH

here goto here

org 0x????

DoTable addwf PCL
TStart Retlw d’0′
etc
As an example of how to use it, say you want to output speech data at 5K samples per second. A simple R2R ladder is on PortB. The speech table has 3000 data points
Start clrf OffsetH
clrf OffsetL

SoundLoop ; 200uS loop time = 5000 samples per second

movlw High(Table)
movwf PCLATH
call Table ; get sound data
movwf PORTB

movlw High(here)
movwf PCLATH ; reset PCLATH

here incf OffsetL ; add 1 to data pointer
btfsc STATUS,C
incf OffsetH

NoUp movlw Low(d’3000′)
xorwf OffsetL,W
btfss STATUS,Z
goto SoundLoop

movlw High(d’3000′)
xorwf OffsetH,W
btfss STATUS,Z
goto SoundLoop
goto Start
;
; SOUND DATA TABLE 3000 ELEMENTS
;
Table movlw High(TStart)
movwf PCLATH
movf OffsetH,W
addwf PCLATH
movlw Low(TStart)
addwf OffsetL,W
btfsc STATUS,C
incf PCLATH

movf OffsetL,W
DoTable addwf PCL
TStart DT “Hello. I’m Mr Ed”

; plus another 2984 data points

end
PS: the text won’t sound like that coming from PORTB
PPS :if you want an easy way to create a 3000 point data table ready for MPASM see

http://www.bubblesoftonline.com/demo/dtimg.html

Dmitry Kiryashov [zews at AHA.RU] says:
AFAIK it can be done in more straight way.
call Dispatcher
; will be returned here

Dispatcher:
movlw High TStart
addwf OffsetH,W
movwf PCLATH

movlw Low TStart
addwf OffsetL,W
skpnc
incf PCLATH,F

movwf PCL ;computed goto with right PCLATH

TStart:
dt data0,data1,data2,… ;retlw’s

Scott Dattalo says:
;*******************************************************************
;write_string
;
; The purpose of this routine is to display a string on the LCD module.
;On entry, W contains the string number to be displayed. The current cursor
;location is the destination of the output.
; This routine can be located anywhere in the code space and may be
;larger than 256 bytes.
;
; psuedo code:
:
; char *string0 = “foo”;
; char *string1 = “bar”;
;
; char *strings[] = { string0, string1};
; char num_strings = sizeof(strings)/sizeof(char *);
;
; void write_string(char string_num)
; {
; char *str;
;
; str = strings[string_num % num_strings];
;
; for( ; *str; str++)
; LCD_WRITE_DATA(*str);
;
; }
;
; Memory used
; buffer2, buffer3
; Calls
; LCD_WRITE_DATA
; Inputs
; W = String Number
;
write_string

andlw WS_TABLE_MASK ;Make sure the string is in range
movwf buffer3 ;Used as an index into the string table
addwf buffer3,w ;to get the string offset
;
addlw LOW(ws_table) ;First, get a pointer to the string
movwf buffer3 ;
;
movlw HIGH(ws_table) ;
skpnc ;
movlw HIGH(ws_table)+1 ;

movwf PCLATH

movf buffer3,w
call ws2 ;First call is to get string offset in
table
movwf buffer2

incf PCLATH,f
incfsz buffer3,w
decf PCLATH,f

call ws2 ;get the high word (of the offset)

movwf PCLATH ;
ws1: ;Now loop through the string
movf buffer2,w
call ws2

andlw 0xff
skpnz ;If the returned byte is zero,
return ; we’ve reached the end

call LCD_WRITE_DATA

incf PCLATH,f ;Point to the next character in the
string
incfsz buffer2,f
decf PCLATH,f

goto ws1

ws2
movwf PCL

#define WS_TABLE_MASK 1 ; This should equal 2^number of strings

; The first part of the table contains pointers to the start of the
; strings. Note that each string has a two word pointer for the low
; and high bytes.

ws_table:
retlw LOW(string0)
retlw HIGH(string0)

retlw LOW(string1)
retlw HIGH(string1)

string0: dt “GPSIM WROTE THIS”,0
string1: dt “A STRING ON ROW 2″,0

also:
• Wave to data table converter
• PIC DSP / filters
• PIC Microcontoller Audio Input / Output
David A Cary of Motorguide Pinpoint Says:
Someone mentioned SoundLoop: … incf OffsetL ; add 1 to data pointer btfsc STATUS,C incf OffsetH
but my little cheat sheet claims that `incf’ only affects the Z bit, not the C bit. Is my cheat sheet leaving something out ? Or is there a bug in this code ? Or am I missing something ? SoundLoop: … incf OffsetL ; add 1 to data pointer btfsc STATUS,Z incf OffsetH
The heavy use of btfsc STATUS,C ; also known as skpnc elsewhere on this page looks OK, because they follow the “addwf” or “addlw” instructions, which do affect the carry bit. — David Cary
Comments:
• The “write_string” subroutine wouldn’t even compile until I made this little tweak:
• write_string:
• ….
• movlw HIGH(ws_table) ;
• skpnc ;
• addlw 1 ; because my assembler choked on “movlw HIGH(ws_table)+1”
Interested:
•